Configurer une géodatabase dans PostgreSQL sous Linux—Aide

Disponible avec une licence Standard ou Advanced.

Vous êtes l'administrateur de PostgreSQL et des géodatabases
L'administrateur de PostgreSQL crée la base de données et l'administrateur de géodatabase crée la géodatabase

La configuration d'une géodatabase dépend des divers scénarios possibles sur votre site. Suivez les instructions correspondant à vos scénarios.

Vous êtes l'administrateur de PostgreSQL et des géodatabases.
L'administrateur de PostgreSQL crée la base de données et l'administrateur de géodatabase crée la géodatabase.

Cette rubrique s'applique aux installations PostgreSQL sur un serveur Linux. Si PostgreSQL est installé sur un serveur Windows, reportez-vous à la rubrique Configurer une géodatabase dans PostgreSQL sous Windows.

Vous êtes l'administrateur de PostgreSQL et des géodatabases

Si vous êtes à la fois administrateur de base de données et de géodatabase et que vous connaissez le mot de passe des deux rôles de connexion, vous pouvez utiliser l'outil de géotraitement Créer une géodatabase d'entreprise ou un script Python pour créer une géodatabase dans PostgreSQL.

L'outil Créer une géodatabase d'entreprise vous permet de configurer facilement une géodatabase, car il crée des objets de base de données et accorde les privilèges requis. Des paramètres par défaut spécifiques sont utilisés à cette fin. Voici les opérations effectuées par l'outil Créer une géodatabase d'entreprise, ainsi que les paramètres utilisés :

Il crée une base de données à l'aide du modèle par défaut de PostgreSQL (template1).
Si vous devez créer la base de données avec un autre modèle, pour utiliser le modèle postgis par exemple, vous devez créer la base de données avant d'exécuter cet outil. Exécutez ensuite l'outil Créer une géodatabase d'entreprise ou le script, puis spécifiez le nom de la base de données que vous avez créée.
Il permet de créer un rôle de connexion sde dans l'agrégat de bases de données et de lui accorder le statut de superutilisateur.
L'utilisateur sde doit être un superutilisateur pour pouvoir créer la géodatabase.
Il crée une structure sde dans la base de données.
Les tables systèmes, les vues, les fonctions et les procédures de la géodatabase sont stockées dans la structure sde.
Il définit l'utilisateur sde comme étant le propriétaire de la structure sde et accorde au rôle public un privilège d'utilisation sur la structure sde.
Les rôles de connexion qui utiliseront la géodatabase doivent pouvoir accéder à la structure sde. Puisqu'il n'existe encore aucun rôle de connexion à la géodatabase, cet outil accorde le privilège d'utilisation au public. Une fois la géodatabase créée, vous pouvez en renforcer la sécurité en retirant au public le privilège d'utilisation sur la structure sde et en l'accordant uniquement aux rôles et aux groupes de connexion devant accéder à la géodatabase.
Il crée une géodatabase.

Tout d'abord, vous devez installer PostgreSQL et configurer l'agrégat de bases de données.

Configurer PostgreSQL

Suivez les étapes ci-dessous pour configurer un agrégat de bases de données PostgreSQL afin de stocker une géodatabase sur un serveur Linux :

Procurez-vous une version prise en charge de PostgreSQL, installez-la et configurez l'agrégat de bases de données.

Vous pouvez télécharger des installations PostgreSQL à partir de My Esri. Si vous utilisez cette installation, aucun paramètre autre que ceux par défaut n'est nécessaire pour utiliser PostgreSQL avec ArcGIS. N'oubliez pas de modifier les paramètres régionaux et les paramètres d'emplacement si vous voulez utiliser des paramètres spécifiques autres que ceux par défaut. Vous pouvez également vous procurer l'installation de PostgreSQL par vous-même.

Pour plus d'instructions sur l'installation et la configuration de PostgreSQL, consultez la documentation sur le site Web PostgreSQL.
Configurez le cluster de bases de données pour accepter les connexions.

Cela suppose que vous modifiiez le fichier pg_hba.conf pour que l'agrégat de bases de données accepte les connexions à distance.
Définissez les variables d'environnement suivantes pour l'utilisateur postgres si elles ne sont pas déjà définies correctement :
- PGDATA : Cette variable doit être définie par l'installation PostgreSQL. Si ce n'est pas le cas, définissez-la sur l'emplacement du répertoire de données PostgreSQL. (Il s'agit du répertoire d'installation de PostgreSQL.)
- LD_LIBRARY_PATH : Définissez la variable LD_LIBRARY_PATH dans le répertoire lib de PostgreSQL. L'emplacement du répertoire lib varie selon l'installation PostgreSQL. Pour déterminer l'emplacement correct de l'installation PostgreSQL, exécutez pg_config en tant qu'utilisateur postgres. Définissez LD_LIBRARY_PATH à la valeur renvoyée par PKGLIBDIR.
- PATH : Définissez la variable PATH pour qu'elle contienne postgresql/bin.
Créez un tablespace dans le cluster de bases de données dans lequel stocker votre base de données. Si vous ne créez aucun tablespace, le tablespace pg_default est utilisé.

Ensuite, installez et configurez un client ArcGIS.

Configurer un client ArcGIS

Exécutez un script Python à partir d'ArcGIS for Desktop (Standard ou Advanced), ArcGIS Engine Runtime avec l'extension Geodatabase Update ou ArcGIS for Server pour créer une géodatabase. Pour exécuter l'outil de géotraitement Créer une géodatabase d'entreprise plutôt qu'un script, utilisez ArcGIS for Desktop.

ArcGIS for Desktop est uniquement pris en charge par les systèmes d'exploitation Windows. Il n'est donc pas installé sur la machine hébergeant PostgreSQL. Vous pouvez installer ArcGIS for Server sur la même machine que PostgreSQL, mais nous le déconseillons car les systèmes de gestion de base de données consomment beaucoup de mémoire.

Installez le client ArcGIS à partir duquel vous allez créer la géodatabase.

Vous créez habituellement une géodatabase à partir d'ArcGIS for Server ou ArcGIS for Desktop (Standard ou Advanced).
Si vous prévoyez d'utiliser ArcGIS for Server avec votre géodatabase dans PostgreSQL, définissez ou modifiez les variables suivantes pour le compte ArcGIS :
- SDEHOME : définissez cette variable sur le répertoire d'installation d'ArcGIS for Server.
  Par exemple, si ArcGIS for Server est installé dans l'emplacement par défaut sur un serveur Linux, définissez export SDEHOME=/home/ags/arcgis/server.
- PG_HOME : Définissez PG_HOME sur /opt/PostgreSQL/<version>.
  Dans cet exemple, PG_HOME est défini pour une installation de PostgreSQL 9.2.2 : export PG_HOME=/opt/PostgreSQL/9.2.
- Si ArcGIS for Server est installé sur un serveur Windows, ajoutez les emplacements PG_HOME\bin et SDEHOME\bin à la variable PATH.
  Par exemple, sous Linux, définissez export PATH=$PATH:$PG_HOME/bin:$SDEHOME/bin.
- Si ArcGIS for Server est installé sur un serveur Linux, ajoutez $PG_HOME/lib et $SDEHOME/lib à la variable LD_LIBRARY_PATH.
  Par exemple, définissez export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PG_HOME/lib:$SDEHOME/lib.

Une fois ArcGIS installé, vous pouvez accéder au fichier st_geometry.so qui doit être placé sur le serveur PostgreSQL.

Placer le fichier st_geometry.so

Vous devez placer le fichier st_geometry.so dans le répertoire lib de PostgreSQL avant de créer une géodatabase. L'emplacement du répertoire lib sur Linux peut varier selon la façon dont vous avez installé PostgreSQL. Pour déterminer l'emplacement correct de l'installation PostgreSQL, exécutez pg_config en tant qu'utilisateur postgres. La valeur qui est renvoyée pour PKGLIBDIR est le répertoire lib dans lequel vous devez placer la bibliothèque st_geometry.

Les fichiers st_geometry.so sont installés avec les clients ArcGIS. La table suivante identifie le répertoire d'installation du client ArcGIS dans lequel figure chaque version de la bibliothèque st_geometry.so. Vous devez utiliser la bibliothèque st_geometry.so correspondant à la version de PostgreSQL que vous utilisez. Si vous ne placez pas la bibliothèque st_geometry.so appropriée dans le répertoire lib de PostgreSQL, vous ne pourrez pas créer de géodatabase.

Version de PostgreSQL	Répertoire d'installation du client ArcGIS
PostgreSQL 9.1	DatabaseSupport/PostgreSQL/9.1/Linux64
PostgreSQL 9.2	DatabaseSupport/PostgreSQL/9.2/Linux64
PostgreSQL 9.3	DatabaseSupport/PostgreSQL/9.3/Linux64

En tant qu'utilisateur racine, transférez le fichier de bibliothèque st_geometry.so du répertoire ArcGIS DatabaseSupport vers le répertoire lib de PostgreSQL.

Votre agrégat de bases de données et le client ArcGIS sont prêts maintenant. Vous pouvez donc créer une géodatabase.

Créer une géodatabase

Vous pouvez exécuter l'outil Créer une géodatabase d'entreprise à partir d'ArcGIS for Desktop (Standard ou Advanced) ou exécuter un script Python à partir d'un client ArcGIS for Desktop (Standard ou Advanced), ArcGIS for Server ou ArcGIS Engine pour créer une géodatabase.

Exécuter l'outil Créer une géodatabase d'entreprise

Si vous avez accès à ArcGIS for Desktop, vous pouvez exécuter un outil de géotraitement pour créer la géodatabase.

Démarrez ArcMap ou ArcCatalog.
Ouvrez l'outil Créer une géodatabase d'entreprise.
Vous pouvez accéder à cet outil, qui se trouve dans jeu d'outils Administration de la géodatabase de la boîte à outils Gestion des données.
Sélectionnez PostgreSQL dans la liste déroulante Plateforme de la base de données.
Saisissez le nom du serveur PostgreSQL dans la zone de texte Instance.
Dans la zone de texte Base de données, tapez le nom de la base de données que vous souhaitez créer pour contenir votre géodatabase.
Remarque :
Indiquez ce nom en minuscules, car les noms d'objet en majuscules ou comportant des minuscules et des majuscules ne sont pas pris en charge pour les géodatabases dans PostgreSQL. Si vous entrez un nom de base de données en lettres majuscules ou en lettres majuscules et minuscules, ArcGIS les convertit en minuscules.
Vous devez vous connecter au cluster de bases de données en tant que super-utilisateur postgres pour créer la base de données et d'autres objets. Par conséquent, la valeur par défaut de la zone de texte Administrateur de base de données est postgres. Si le nom de votre super-utilisateur postgres est différent, saisissez ce nom dans la zone de texte Administrateur de base de données.
Entrez le mot de passe du super-utilisateur postgres dans la zone de texte Mot de passe administrateur de base de données.

L'administrateur de géodatabase doit s'appeler sde dans PostgreSQL. Par conséquent, la zone de texte Administrateur de géodatabase est déjà renseignée avec la valeur sde.

Tapez un mot de passe pour l'administrateur de géodatabase (sde) dans la zone de texte Mot de passe administrateur de géodatabase.
Si l'utilisateur sde existe déjà dans le cluster de bases de données, tapez le mot de passe de l'utilisateur existant ; une structure sde est créée dans la base de données. Si l'utilisateur n'existe pas encore, un utilisateur sde doté du mot de passe que vous indiquez est créé dans le cluster de bases de données et une structure correspondante est créée dans la base de données. L'autorisation USAGE est accordée sur la structure sde au rôle de groupe public.
Astuce:
Pour renforcer la sécurité de la structure après la création de la géodatabase, vous pouvez annuler l'autorisation USAGE du rôle de groupe public, créer un rôle de groupe, accorder l'autorisation USAGE sur la structure sde à ce rôle, puis accorder le rôle de groupe à tous les rôles de connexion devant accéder à la géodatabase.
Si vous souhaitez utiliser par défaut pour la base de données un tablespace préconfiguré, saisissez son nom dans la zone de texte Nom de l'espace de table.
Cet outil ne permet pas de créer un tablespace ; vous devez soit spécifier un tablespace existant, soit laisser cette zone de texte vide. Si vous ne spécifiez aucun tablespace, la base de données est créée dans pg_default.
Pour spécifier un Fichier d'autorisation, recherchez et choisissez le fichier de codes clés qui a été créé lorsque vous avez autorisé ArcGIS for Server Enterprise.
Ce fichier figure dans le répertoire \\Program Files\ESRI\License<release#>\sysgen des serveurs Windows et dans le répertoire /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen sous Linux. Si vous ne l'avez pas déjà fait, autorisez ArcGIS for Server à créer ce fichier.
Cliquez sur OK pour exécuter l'outil.
Un fichier journal correspondant à la création de la géodatabase (GDBCreateGeodatabase<#>.log) est écrit dans le répertoire spécifié pour votre variable %TEMP% sur l'ordinateur sur lequel l'outil est exécuté.

Vous possédez maintenant une géodatabase dans PostgreSQL.

Ensuite, créez un utilisateur autorisé à charger des données dans la géodatabase.

Exécuter un script Python

Vous pouvez copier, enregistrer et exécuter le script fourni ici pour créer une géodatabase à partir d'un client ArcGIS for Desktop (Standard ou Advanced), ArcGIS for Server (Standard ou Advanced) ou ArcGIS Engine (avec l'extension Geodatabase Update).

Créez un fichier texte sur l'ordinateur du client ArcGIS, puis copiez-y le script suivant.

"""
Name: create_enterprise_gdb.py
Description: Provide connection information to a DBMS instance and create an enterprise geodatabase.
Type  create_enterprise_gdb.py -h or create_enterprise_gdb.py --help for usage
"""

# Import system modules
import arcpy
import os
import optparse
import sys


# Define usage and version
parser = optparse.OptionParser(usage = "usage: %prog [Options]", version="%prog 1.0 for " + arcpy.GetInstallInfo()['Version'] )

#Define help and options
parser.add_option ("--DBMS", dest="Database_type", type="choice", choices=['SQLSERVER', 'ORACLE', 'POSTGRESQL', ''], default="", help="Type of enterprise DBMS:  SQLSERVER, ORACLE, or POSTGRESQL.")                   
parser.add_option ("-i", dest="Instance", type="string", default="", help="DBMS instance name")
parser.add_option ("-D", dest="Database", type="string", default="none", help="Database name:  Do not specify for Oracle")
parser.add_option ("--auth", dest="Account_authentication", type ="choice", choices=['DATABASE_AUTH', 'OPERATING_SYSTEM_AUTH'], default='DATABASE_AUTH', help="Authentication type options (case-sensitive):  DATABASE_AUTH, OPERATING_SYSTEM_AUTH.  Default=DATABASE_AUTH")
parser.add_option ("-U", dest="Dbms_admin", type="string", default="", help="DBMS administrator user")
parser.add_option ("-P", dest="Dbms_admin_pwd", type="string", default="", help="DBMS administrator password")
parser.add_option ("--schema", dest="Schema_type", type="choice", choices=['SDE_SCHEMA', 'DBO_SCHEMA'], default="SDE_SCHEMA", help="Schema type  applies to geodatabases in SQL Server only. Type SDE_SCHEMA to create geodatabase in SDE schema or type DBO_SCHEMA to create geodatabase in DBO schema. Default=SDE_SCHEMA")
parser.add_option ("-u", dest="Gdb_admin", type="string", default="", help="Geodatabase administrator user name; Must always be sde for PostgreSQL, sde-schema geodatabases in SQL Server, and master sde geodatabase in Oracle")
parser.add_option ("-p", dest="Gdb_admin_pwd", type="string", default="", help="Geodatabase administrator password")
parser.add_option ("-t", dest="Tablespace", type="string", default="", help="Tablespace name; For PostgreSQL, type name of existing tablespace in which to store database. If no tablespace name specified, pg_default is used. For Oracle, type name of existing tablespace, or, if tablespace with specified name does not exist, it will be created and set as the default tablespace for the sde user. If no tablespace name is specified, SDE_TBS tablespace is created and set as sde user default. Tablespace name not supported for SQL Server.")
parser.add_option ("-l", dest="Authorization_file", type="string", default="", help="Full path and name of authorization file; file created when ArcGIS for Server Enterprise authorized, and stored in \\Program Files\ESRI\License<release#>\sysgen on Windows or /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen on Linux")
# Check if value entered for option
try:
	(options, args) = parser.parse_args()

	
	#Check if no system arguments (options) entered
	if len(sys.argv) == 1:
		print("%s: error: %s\n" % (sys.argv[0], "No command options given"))
		parser.print_help()
		sys.exit(3)

	#Usage parameters for spatial database connection
	database_type = options.Database_type.upper()
	instance = options.Instance
	database = options.Database.lower()	
	account_authentication = options.Account_authentication.upper()
	dbms_admin = options.Dbms_admin
	dbms_admin_pwd = options.Dbms_admin_pwd
	schema_type = options.Schema_type.upper()
	gdb_admin = options.Gdb_admin
	gdb_admin_pwd = options.Gdb_admin_pwd	
	tablespace = options.Tablespace
	license = options.Authorization_file
	
	
	if (database_type == "SQLSERVER"):
		database_type = "SQL_SERVER"
	
	if( database_type ==""):	
		print(" \n%s: error: \n%s\n" % (sys.argv[0], "DBMS type (--DBMS) must be specified."))
		parser.print_help()
		sys.exit(3)		
		
	if (license == ""):
		print(" \n%s: error: \n%s\n" % (sys.argv[0], "Authorization file (-l) must be specified."))
		parser.print_help()
		sys.exit(3)			
	
	if(database_type == "SQL_SERVER"):
		if(schema_type == "SDE_SCHEMA" and gdb_admin.lower() != "sde"):
			print("\n%s: error: %s\n" % (sys.argv[0], "To create SDE schema on SQL Server, geodatabase administrator must be SDE."))
			sys.exit(3)
		if (schema_type == "DBO_SCHEMA" and gdb_admin != ""):
			print("\nWarning: %s\n" % ("Ignoring geodatabase administrator specified when creating DBO schema..."))
		if( account_authentication == "DATABASE_AUTH" and dbms_admin == ""):
			print("\n%s: error: %s\n" % (sys.argv[0], "DBMS administrator must be specified with database authentication"))
			sys.exit(3)
		if( account_authentication == "OPERATING_SYSTEM_AUTH" and dbms_admin != ""):
			print("\nWarning: %s\n" % ("Ignoring DBMS administrator specified when using operating system authentication..."))
	else:
		if (schema_type == "DBO_SCHEMA"):
			print("\nWarning: %s %s, %s\n" % ("Only SDE schema is supported on", database_type, "switching to SDE schema..." ))
			
		if( gdb_admin.lower() == ""):
			print("\n%s: error: %s\n" % (sys.argv[0], "Geodatabase administrator must be specified."))
			sys.exit(3)

		if( gdb_admin.lower() != "sde"):
			if (database_type == "ORACLE"):
				print("\nGeodatabase admin user is not SDE, creating user schema geodatabase on Oracle...\n")
			else:
				print("\n%s: error: %s for %s.\n" % (sys.argv[0], "Geodatabase administrator must be SDE", database_type))
				sys.exit(3)
			
		if( dbms_admin == ""):
			print("\n%s: error: %s\n" % (sys.argv[0], "DBMS administrator must be specified!"))
			sys.exit(3)

		if (account_authentication == "OPERATING_SYSTEM_AUTH"):
			print("Warning: %s %s, %s\n" % ("Only database authentication is supported on", database_type, "switching to database authentication..." ))

	# Get the current product license
	product_license=arcpy.ProductInfo()
	
	
	# Checks required license level
	if product_license.upper() == "ARCVIEW" or product_license.upper() == 'ENGINE':
		print("\n" + product_license + " license found!" + " Creating an enterprise geodatabase requires an ArcGIS for Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS for Server license.")
		sys.exit("Re-authorize ArcGIS before creating enterprise geodatabase.")
	else:
		print("\n" + product_license + " license available!  Continuing to create...")
		arcpy.AddMessage("+++++++++")
	
	
	try:
		print("Creating enterprise geodatabase...\n")
		arcpy.CreateEnterpriseGeodatabase_management(database_platform=database_type,instance_name=instance, database_name=database, account_authentication=account_authentication, database_admin=dbms_admin, database_admin_password=dbms_admin_pwd, sde_schema=schema_type, gdb_admin_name=gdb_admin, gdb_admin_password=gdb_admin_pwd, tablespace_name=tablespace, authorization_file=license)
		for i in range(arcpy.GetMessageCount()):
			arcpy.AddReturnMessage(i)
		arcpy.AddMessage("+++++++++\n")
	except:
		for i in range(arcpy.GetMessageCount()):
			arcpy.AddReturnMessage(i)
			
#Check if no value entered for option	
except SystemExit as e:
	if e.code == 2:
		parser.usage = ""
		print("\n")
		parser.print_help()   
		parser.exit(2)

Enregistrez le fichier avec l'extension .py.
Exécutez le script en indiquant les options et informations propres à votre site.
Dans l'exemple suivant, exécuté sur un ordinateur Linux, le fichier create_gdb.py est exécuté pour un agrégat de bases de données pgprode, en tant que superutilisateur postgres avec le mot de passe N0pe3king!. Il génère une base de données appelée entgdb dans un tablespace appelé gis et crée le rôle de connexion sde avec le mot de passe Tgdbst@rtsh3r3. Un fichier de codes clés se trouvant dans l'emplacement par défaut d'ArcGIS Server permet d'autoriser la géodatabase.
```
./create_gdb.py --DBMS POSTGRESQL -i pgprod -D entgdb --auth DATABASE_AUTH 
-U postgres -P N0pe3king! -u sde -p Tgdbst@rtsh3r3 -t gis -l /usr/arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License10.3/sysgen/keycodes
```
Dans cet exemple, le même script est exécuté sur un ordinateur Windows :
```
create_gdb.py --DBMS POSTGRESQL -i pgprod -D entgdb --auth DATABASE_AUTH 
-U postgres -P N0pe3king! -u sde -p Tgdbst@rtsh3r3 -t gis -l \\Program Files\ESRI\License10.3\sysgen\keycodes
```
Astuce:
Saisissez -h ou --help à l'invite de commande pour obtenir de l'aide sur la syntaxe.

Vous possédez maintenant une géodatabase dans PostgreSQL.

Ensuite, créez un utilisateur autorisé à charger des données dans la géodatabase.

L'administrateur de PostgreSQL crée la base de données et l'administrateur de géodatabase crée la géodatabase

Si la personne qui crée la géodatabase ne connaît pas le mot de passe de l'administrateur de base de données (le superutilisateur postgres), ce dernier peut configurer la base de données et l'administrateur de géodatabase peut s'y connecter avec le rôle de connexion sde, puis créer une géodatabase dans la base de données à l'aide de l'outil de géotraitement Activer une géodatabase d’entreprise ou un script Python.

L'outil Activer une géodatabase d’entreprise utilise en entrée un fichier de connexion à une base de données et crée les vues, les fonctions, les procédures et les tables système de la géodatabase dans la structure sde. L'administrateur de base de données doit configurer les informations suivantes dans l'agrégat de bases de données PostgreSQL avant d'exécuter l'outil :

Un rôle de connexion appelé sde doté du statut de superutilisateur
Une base de données
Une structure sde dans la base de données appartenant au rôle de connexion sde
La bibliothèque st_geometry doit figurer dans le répertoire d'installation de PostgreSQL

Configurer PostgreSQL

Tout d'abord, l'administrateur de base de données doit préparer PostgreSQL pour le stockage d'une géodatabase.

Les instructions suivantes sont destinées à l'administrateur de base de données qui configure l'agrégat de bases de données PostgreSQL sur un serveur Linux. Tous les noms d'objets de base de données (rôles de connexion, base de données et structure) doivent comporter uniquement des minuscules.

Procurez-vous une version prise en charge de PostgreSQL, installez-la et configurez l'agrégat de bases de données.

Vous pouvez télécharger des installations PostgreSQL à partir de My Esri. Si vous utilisez cette installation, aucun paramètre autre que ceux par défaut n'est nécessaire pour utiliser PostgreSQL avec ArcGIS. N'oubliez pas de modifier les paramètres régionaux et les paramètres d'emplacement si vous voulez utiliser des paramètres spécifiques autres que ceux par défaut. Vous pouvez également vous procurer l'installation de PostgreSQL par vous-même.

Pour plus d'instructions sur l'installation et la configuration de PostgreSQL, consultez la documentation sur le site Web PostgreSQL.
Configurez le cluster de bases de données pour accepter les connexions.

Cela suppose que vous modifiiez le fichier pg_hba.conf pour que l'agrégat de bases de données accepte les connexions à distance.
Définissez les variables d'environnement suivantes pour l'utilisateur postgres si elles ne sont pas déjà définies correctement :
- PGDATA : Cette variable doit être définie par l'installation PostgreSQL. Si ce n'est pas le cas, définissez-la sur l'emplacement du répertoire de données PostgreSQL. (Il s'agit du répertoire d'installation de PostgreSQL.)
- LD_LIBRARY_PATH : Définissez la variable LD_LIBRARY_PATH dans le répertoire lib de PostgreSQL. L'emplacement du répertoire lib varie selon l'installation PostgreSQL. Pour déterminer l'emplacement correct de l'installation PostgreSQL, exécutez pg_config en tant qu'utilisateur postgres. Définissez LD_LIBRARY_PATH à la valeur renvoyée par PKGLIBDIR.
- PATH : Définissez la variable PATH pour qu'elle contienne postgresql/bin.
Vous pouvez également créer un tablespace dans l'agrégat de bases de données dans lequel stocker votre base de données.
Créez un rôle de connexion appelé sde et ayant le statut de superutilisateur.

Astuce:

Si l'administrateur de géodatabase ne doit pas supprimer de connexions à la base de données, vous pouvez retirer le statut de superutilisateur du rôle sde après la création de la géodatabase, mais vous devez l'accorder de nouveau pour toute mise à niveau de la géodatabase.
Créez la base de données qui doit stocker la géodatabase.
Créez une structure nommée sde dans la base de données et accordez au rôle de connexion sde des privilèges sur cette structure.
Vous devez également placer le fichier de bibliothèque st_geometry.so dans le répertoire lib de PostgreSQL. Le fichier est installé avec les clients ArcGIS. Demandez à l'administrateur de géodatabase de vous transmettre le fichier correspondant à votre installation PostgreSQL une fois le client ArcGIS installé.

Pendant que vous êtes connecté en tant qu'utilisateur racine, placez le fichier st_geometry.so approprié dans le répertoire lib de PostgreSQL. L'emplacement du répertoire lib sur Linux peut varier selon la façon dont vous avez installé PostgreSQL. Pour déterminer l'emplacement correct de l'installation PostgreSQL, exécutez pg_config en tant qu'utilisateur postgres. La valeur qui est renvoyée pour PKGLIBDIR est le répertoire lib dans lequel vous devez placer la bibliothèque st_geometry.

Attention :

Le répertoire DatabaseSupport d'ArcGIS for Server est créé avec des autorisations définies sur 700. Si vous utilisez le fichier st_geometry.so installé avec ArcGIS for Server, modifiez les autorisations dans le fichier sur 755 lorsque vous vous connectez en tant qu'utilisateur racine pour déplacer le fichier st_geometry.so vers le répertoire lib de PostgreSQL. Si vous n'effectuez pas cette opération, l'utilisateur sde ne pourra pas y accéder pour créer une géodatabase.
Communiquez à l'administrateur de géodatabase les informations de connexion à la base de données.

L'administrateur de géodatabase doit connaître le nom de l'agrégat de bases de données, le nom de la base de données et le mot de passe du rôle de connexion sde.

La base de données est maintenant configurée et l'administrateur de géodatabase peut préparer un client ArcGIS et créer une géodatabase.

Configurer un client ArcGIS

L'administrateur de géodatabase doit suivre les étapes ci-dessous pour préparer le client ArcGIS pour la création d'une géodatabase :

Installez le client ArcGIS à partir duquel vous allez créer la géodatabase.

Vous créez habituellement une géodatabase à partir d'ArcGIS for Server ou d'ArcGIS for Desktop (Standard ou Advanced).

Une fois le client ArcGIS installé, vous pouvez accéder au fichier st_geometry.so dont l'administrateur de base de données a besoin pour finaliser la configuration de l'agrégat de bases de données. Transmettez le fichier approprié à l'administrateur de base de données.

La table suivante identifie le répertoire d'installation du client ArcGIS dans lequel figure chaque version de la bibliothèque st_geometry.so. Vous devez utiliser la bibliothèque st_geometry.so correspondant à la version de PostgreSQL dans laquelle vous créez votre géodatabase. Si vous placez une version incorrecte de la bibliothèque st_geometry.so dans le répertoire lib de PostgreSQL, vous ne pourrez pas créer de géodatabase.

Version de PostgreSQL	Répertoire d'installation du client ArcGIS
PostgreSQL 9.1	DatabaseSupport/PostgreSQL/9.1/Linux64
PostgreSQL 9.2	DatabaseSupport/PostgreSQL/9.2/Linux64
PostgreSQL 9.3	DatabaseSupport/PostgreSQL/9.3/Linux64

Si vous prévoyez d'utiliser ArcGIS for Server avec votre géodatabase dans PostgreSQL, définissez ou modifiez les variables suivantes pour le compte ArcGIS :
- SDEHOME : définissez cette variable sur le répertoire d'installation d'ArcGIS for Server.
  Par exemple, si ArcGIS for Server est installé dans l'emplacement par défaut sur un serveur Linux, définissez export SDEHOME=/home/ags/arcgis/server.
- PG_HOME : Définissez PG_HOME sur /opt/PostgreSQL/<version>.
  Dans cet exemple, PG_HOME est défini pour une installation de PostgreSQL 9.2.2 : export PG_HOME=/opt/PostgreSQL/9.2.
- Si ArcGIS for Server est installé sur un serveur Windows, ajoutez les emplacements PG_HOME\bin et SDEHOME\bin à la variable PATH.
  Par exemple, sous Linux, définissez export PATH=$PATH:$PG_HOME/bin:$SDEHOME/bin.
- Si ArcGIS for Server est installé sur un serveur Linux, ajoutez $PG_HOME/lib et $SDEHOME/lib à la variable LD_LIBRARY_PATH.
  Par exemple, définissez export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PG_HOME/lib:$SDEHOME/lib.

Votre client ArcGIS est prêt à se connecter à la base de données et à créer une géodatabase.

Créer une géodatabase

L'administrateur de géodatabase peut exécuter l'outil Activer une géodatabase d’entreprise à partir d'ArcGIS for Desktop (Standard ou Advanced) ou un script Python à partir d'un client ArcGIS for Desktop, ArcGIS for Server ou ArcGIS Engine pour créer une géodatabase dans la base de données existante.

Exécutez l'outil Activer une géodatabase d'entreprise.

Si vous avez accès à ArcGIS for Desktop, vous pouvez exécuter un outil de géotraitement pour créer la géodatabase.

Démarrez ArcMap ou ArcCatalog.
Connectez-vous à la base de données PostgreSQL à partir de l'arborescence du Catalogue avec le rôle de connexion sde.
N'oubliez pas d'enregistrer le mot de passe de l'utilisateur dans la boîte de dialogue Connexion à la base de données.
Cliquez sur la connexion avec le bouton droit de la souris, puis sélectionnez Activer une géodatabase.
La fenêtre Activer une géodatabase d’entreprise s'ouvre et le champ Connexion à la géodatabase en entrée est renseigné pour afficher le nom du fichier de connexion et son emplacement.
Accédez au fichier d'autorisation d'ArcGIS for Server que vous avez créé lorsque vous avez autorisé ArcGIS for Server et ajoutez-le à la zone de texte Fichier d’autorisation.
Lorsque vous utilisez l'assistant d'autorisation d'ArcGIS for Server, un fichier de codes clés est écrit sur le serveur où le logiciel est installé. Si vous avez autorisé ArcGIS for Server sur un système Linux, le fichier de codes clés a été crée dans /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release>/sysgen. Si vous l'avez autorisé sur un serveur Windows, le fichier a été créé dans Program Files\ESRI\License<release>\sysgen. Si vous ne l'avez pas déjà fait, autorisez ArcGIS for Server à créer ce fichier.
Cliquez sur OK pour exécuter l'outil.

Une géodatabase est créée dans la base de données.

Un fichier journal correspondant à la création de la géodatabase (GDBCreateGeodatabase<#>.log) est écrit dans le répertoire spécifié pour votre variable %TEMP% sur l'ordinateur sur lequel l'outil est exécuté. Si vous rencontrez un problème lors de l'exécution de l'outil, consultez ce fichier journal pour le résoudre.

Ensuite, créez un utilisateur autorisé à charger des données dans la géodatabase.

Exécuter un script Python

Pour créer la géodatabase en exécutant un script à partir d'une installation ArcGIS for Server, ArcGIS for Desktop (Standard ou Advanced) ou ArcGIS Engine, utilisez le script fourni ici.

Créez un fichier texte sur la machine ArcGIS for Server, puis copiez le script suivant à l'intérieur.

"""
Name: enable_enterprise_gdb.py
Description: Provide connection information to an enterprise database
and enable enterprise geodatabase.
Type enable_enterprise_gdb.py -h or enable_enterprise_gdb.py --help for usage
Author: Esri
"""

# Import system modules
import arcpy, os, optparse, sys


# Define usage and version
parser = optparse.OptionParser(usage = "usage: %prog [Options]", version="%prog 1.0 for " + arcpy.GetInstallInfo()['Version'] )

#Define help and options
parser.add_option ("--DBMS", dest="Database_type", type="choice", choices=['SQLSERVER', 'ORACLE', 'POSTGRESQL', 'DB2','INFORMIX','DB2ZOS', ''], default="", help="Type of enterprise DBMS:  SQLSERVER, ORACLE, POSTGRESQL, DB2, INFORMIX, or DB2ZOS.")
parser.add_option ("-i", dest="Instance", type="string", default="", help="DBMS instance name")
parser.add_option ("--auth", dest="account_authentication", type ="choice", choices=['DATABASE_AUTH', 'OPERATING_SYSTEM_AUTH'], default='DATABASE_AUTH', help="Authentication type options (case-sensitive):  DATABASE_AUTH, OPERATING_SYSTEM_AUTH.  Default=DATABASE_AUTH")
parser.add_option ("-u", dest="User", type="string", default="", help="Geodatabase administrator user name")
parser.add_option ("-p", dest="Password", type="string", default="", help="Geodatabase  administrator password")
parser.add_option ("-D", dest="Database", type="string", default="none", help="Database name:  Not required for Oracle")
parser.add_option ("-l", dest="Authorization_file", type="string", default="", help="Full path and name of authorization file")


# Check if value entered for option
try:
	(options, args) = parser.parse_args()

	
#Check if no system arguments (options) entered
	if len(sys.argv) == 1:
		print "%s: error: %s\n" % (sys.argv[0], "No command options given")
		parser.print_help()
		sys.exit(3)
	

	#Usage parameters for spatial database connection
	database_type = options.Database_type.upper()
	instance = options.Instance
	account_authentication = options.account_authentication.upper()
	username = options.User.lower() 
	password = options.Password	
	database = options.Database.lower()
	license = options.Authorization_file


	if( database_type ==""):	
		print " \n%s: error: \n%s\n" % (sys.argv[0], "DBMS type (--DBMS) must be specified.")
		parser.print_help()
		sys.exit(3)		
		
	if (license == ""):
		print " \n%s: error: \n%s\n" % (sys.argv[0], "Authorization file (-l) must be specified.")
		parser.print_help()
		sys.exit(3)

	if (database_type == "SQLSERVER"):
		database_type = "SQL_SERVER"
		
	# Get the current product license
	product_license=arcpy.ProductInfo()
	
	if (license == ""):
		print " \n%s: error: %s\n" % (sys.argv[0], "Authorization file (-l) must be specified.")
		parser.print_help()
		sys.exit(3)
	
	# Checks required license level
	if product_license.upper() == "ARCVIEW" or product_license.upper() == 'ENGINE':
		print "\n" + product_license + " license found!" + "  Enabling enterprise geodatabase functionality requires an ArcGIS for Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS for Server license."
		sys.exit("Re-authorize ArcGIS before enabling an enterprise geodatabase.")
	else:
		print "\n" + product_license + " license available!  Continuing to enable..."
		arcpy.AddMessage("+++++++++")
	
	# Local variables
	instance_temp = instance.replace("\\","_")
	instance_temp = instance_temp.replace("/","_")
	instance_temp = instance_temp.replace(":","_")
	Conn_File_NameT = instance_temp + "_" + database + "_" + username    
	
	if os.environ.get("TEMP") == None:
		temp = "c:\\temp"	
	else:
		temp = os.environ.get("TEMP")
	
	if os.environ.get("TMP") == None:
		temp = "/usr/tmp"		
	else:
		temp = os.environ.get("TMP")  
	

	Connection_File_Name = Conn_File_NameT + ".sde"
	Connection_File_Name_full_path = temp + os.sep + Conn_File_NameT + ".sde"
	
	# Check for the .sde file and delete it if present
	arcpy.env.overwriteOutput=True
	if os.path.exists(Connection_File_Name_full_path):
		os.remove(Connection_File_Name_full_path)
	
	print "\nCreating Database Connection File...\n"	
	# Process: Create Database Connection File...
	# Usage:  out_file_location, out_file_name, DBMS_TYPE, instnace, database, account_authentication, username, password, save_username_password(must be true)
	arcpy.CreateDatabaseConnection_management(out_folder_path=temp, out_name=Connection_File_Name, database_platform=database_type, instance=instance, database=database, account_authentication=account_authentication, username=username, password=password, save_user_pass="TRUE")
        for i in range(arcpy.GetMessageCount()):
		if "000565" in arcpy.GetMessage(i):   #Check if database connection was successful
			arcpy.AddReturnMessage(i)
			arcpy.AddMessage("\n+++++++++")
			arcpy.AddMessage("Exiting!!")
			arcpy.AddMessage("+++++++++\n")
			sys.exit(3)            
		else:
			arcpy.AddReturnMessage(i)
			arcpy.AddMessage("+++++++++\n")
	
	
	# Process: Enable geodatabase...
	try:
		print "Enabling Enterprise Geodatabase...\n"
		arcpy.EnableEnterpriseGeodatabase_management(input_database=Connection_File_Name_full_path, authorization_file=license)
		for i in range(arcpy.GetMessageCount()):
			arcpy.AddReturnMessage(i)
		arcpy.AddMessage("+++++++++\n")
	except:
		for i in range(arcpy.GetMessageCount()):
			arcpy.AddReturnMessage(i)
			
	if os.path.exists(Connection_File_Name_full_path):
		os.remove(Connection_File_Name_full_path)
			
#Check if no value entered for option	
except SystemExit as e:
	if e.code == 2:
		parser.usage = ""
		print "\n"
		parser.print_help() 
		parser.exit(2)

Enregistrez le fichier avec l'extension .py.
Exécutez le script en indiquant les options et informations propres à votre site.
Dans l'exemple suivant, le fichier enable_gdb.py est exécuté pour la base de données spdata sur l'agrégat de bases de données pgprod. La connexion est établie avec l'identifiant de connexion sde et le mot de passe Tgdbst@rtsh3r3. Un fichier de codes clés se trouvant dans l'emplacement par défaut d'ArcGIS Server permet d'autoriser la géodatabase.
```
./enable_gdb.py --DBMS POSTGRESQL -i pgprod --auth DATABASE_AUTH 
-u sde -p Tgdbst@rtsh3r3 -D spdata -l /usr/arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License10.3/sysgen/keycodes
```
Astuce:
Saisissez -h ou --help à l'invite de commande pour obtenir de l'aide sur la syntaxe.

Vous possédez maintenant une géodatabase dans PostgreSQL.

Ensuite, créez un utilisateur autorisé à charger des données dans la géodatabase.