Créer une géodatabase d'entreprise dans SQL Server—Aide

Disponible avec une licence Standard ou Advanced.

Vous êtes administrateur de géodatabase et de SQL Server
L'administrateur de SQL Server crée la base de données et l'administrateur de géodatabase crée la géodatabase

La configuration d'une géodatabase dans Microsoft SQL Server dépend des divers scénarios possibles sur votre site. Suivez les instructions correspondant au scénario applicable à votre organisation.

Vous êtes administrateur de géodatabase et de SQL Server.
L'administrateur de SQL Server crée la base de données et l'administrateur de géodatabase crée la géodatabase.

Vous êtes administrateur de géodatabase et de SQL Server

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 identifiants 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 SQL Server.

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 les fichiers de base de données (MDF et LDF) à l'emplacement par défaut de SQL Server sur le serveur.
Il définit les options de la base de données SQL Server READ_COMMITTED_SNAPSHOT et ALLOW_SNAPSHOT_ISOLATION sur ON.
Les tailles de fichier de base de données seront soit celles que vous avez définies pour la base de données du modèle SQL Server, soit 500 Mo pour le fichier MDF et 125 Mo pour le fichier LDF, selon celle qui est la plus importante.
Si vous créez une géodatabase dans une structure nommée sde, l'outil crée un identifiant de connexion sde authentifié par SQL Server dans l'instance SQL Server, puis un utilisateur sde dans la base de données, en l'associant à l'identifiant de connexion sde. Il crée ensuite une structure sde dans la base de données et octroie à l'utilisateur sde des privilèges l'autorisant à créer une géodatabase et à interrompre les connexions à l'instance SQL Server.
Il crée une géodatabase.

Avant d'exécuter l'outil ou le script de création d'une géodatabase, vous devez configurer une instance SQL Server.

Installer et configurer le serveur SQL

Avant de créer une géodatabase, vous devez installer SQL Server et configurer l'instance. La configuration de l'instance varie en fonction des besoins spécifiques de votre organisation. Toutefois, notez que l'instance SQL Server doit être un classement insensible à la casse.

Vérifiez la configuration système requise d'ArcGIS pour SQL Server avant de créer une géodatabase, pour vous assurer que le système de gestion de base de données, ArcGIS et le matériel que vous souhaitez utiliser sont bien pris en charge. Lorsque vous avez installé SQL Server, configurez l'instance SQL Server de sorte qu'elle accepte des connexions à distance. Par défaut, elles ne sont pas activées.

Consultez la documentation Microsoft qui contient des informations sur l'installation et la configuration de SQL Server.

Une fois SQL Server installé et configuré, installez les clients ArcGIS et SQL Server.

Installer les clients

Vous pouvez installer ArcGIS Desktop (Desktop Standard ou Desktop Advanced), ArcGIS Engine Runtime avec l'extension Geodatabase Update ou ArcGIS Server (édition Enterprise) et exécuter un script Python à partir de l'un de ces produits 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, installez ArcGIS Desktop.

Dans la plupart des cas, vos clients ArcGIS sont installés sur un ordinateur autre que celui où SQL Server est installé. Ainsi, pour vous connecter à la base de données, un client SQL Server pris en charge doit être installé sur l'ordinateur du client ArcGIS. Consultez la documentation Microsoft pour déterminer quelle version du client SQL Server vous devez installer pour vous connecter à la version de SQL Server que vous utilisez.

Vous pouvez télécharger le client SQL Server à partir de My Esri ou du Centre de téléchargement Microsoft. Suivez les instructions de Microsoft pour installer le client SQL Server sur votre ordinateur client.

Installez le client ArcGIS à utiliser pour créer la géodatabase.

Suivez les instructions des guides d'installation du logiciel.
Installez un client SQL Server sur l'ordinateur du client ArcGIS.

Si vous installez le client SQL Server sur un système d'exploitation 64 bits, utilisez le fichier exécutable du client SQL Server 64 bits. Ce fichier exécutable installe le client 32 bits et 64 bits, ce qui lui permet de fonctionner avec des applications ArcGIS 32 bits, telles qu'ArcMap et des applications ArcGIS 64 bits, telles qu'ArcGIS Server ou ArcGIS Pro. Si vous exécutez le client SQL Server 32 bits sur un système d'exploitation 64 bits, il échouera.

Vous pouvez maintenant 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 Desktop ou exécuter un script Python à partir d'un client ArcGIS Desktop, ArcGIS Server ou ArcGIS Engine pour créer une base de données et une géodatabase.

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

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

Procédez comme suit pour créer une géodatabase à l'aide de l'outil Créer une géodatabase d'entreprise d'ArcMap :

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 SQL Server dans la liste déroulante Plateforme de la base de données.
Tapez le nom de l'instance SQL Server à laquelle vous allez vous connecter dans la zone de texte Instance.
Dans la zone de texte Base de données, indiquez le nom de la base de données dans laquelle vous souhaitez stocker la géodatabase.

Si aucune base de données de ce nom n'existe dans l'instance SQL Server, elle est créée. Si elle existe déjà, la base de données que vous spécifiez est utilisée pour stocker la géodatabase.
Connectez-vous à SQL Server en tant qu'administrateur système. Pour ce faire, utilisez une connexion authentifiée par le système d'exploitation, qui fait partie du rôle de serveur fixe sysadmin dans SQL Server ou entrez un nom d'utilisateur de base de données et le mot de passe d'un administrateur système.
- Pour vous connecter avec une connexion authentifiée par le système d'exploitation, reportez-vous à la rubrique Authentification du système d'exploitation. Vous devez avoir ouvert une session Windows avec le nom de connexion approprié pour utiliser cette option.
- Pour vous connecter comme administrateur de système, saisissez le nom d'utilisateur sysadmin dans la zone de texte Administrateur de base de données et le mot de passe correspondant dans la zone de texte Mot de passe administrateur de géodatabase.
Choisissez la structure qui doit contenir la géodatabase.
- Si vous souhaitez d'un utilisateur sde soit l'administrateur de géodatabase et que la géodatabase soit stockée dans une structure de l'utilisateur sde, cochez l'option Schéma détenu par Sde.
- Si vous souhaitez que l'utilisateur dbo soit l'administrateur de géodatabase et que la géodatabase soit stockée dans un schéma dbo, décochez l'option Schéma Sde.
Pour plus d'informations sur le stockage de la géodatabase dans la structure sde ou dbo, reportez-vous à la rubrique Comparaison entre propriétaires de géodatabase dans SQL Server.

Si vous choisissez une structure détenue par un utilisateur sde, la zone de texte Administrateur de géodatabase indique déjà sde. Si aucun utilisateur de ce nom n'existe, l'utilisateur et sa structure correspondante sont créés et les privilèges nécessaires à la création d'une géodatabase sont attribués à l'utilisateur.

Si vous utilisez l'authentification de base de données et un schéma dbo pour stocker la géodatabase, saisissez le nom d'un utilisateur dbo dans l'instance SQL Server dans la zone de texte Administrateur de géodatabase.

Si vous utilisez l'authentification du système d'exploitation pour vous connecter à la base de données, votre identifiant de connexion actuel doit figurer dans le rôle de serveur fixe sysadmin SQL Server pour créer une géodatabase à structure dbo.

Saisissez un mot de passe pour l'administrateur de géodatabase dans la zone de texte Mot de passe de l'administrateur de géodatabase.

Si l'administrateur de géodatabase spécifié existe déjà dans la base de données, veillez à entrer le mot de passe correspondant à l'utilisateur existant ; cet outil ne modifiera pas le mot de passe.
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 Server (édition Enterprise).

Ce fichier figure dans le dossier \\Program Files\ESRI\License<release#>\sysgen sur les serveurs Windows. Copiez le fichier de codes clés dans un emplacement accessible avec l'outil Créer une géodatabase d'entreprise. Si vous ne l'avez pas déjà fait, autorisez ArcGIS Server à créer ce fichier.
Cliquez sur OK pour exécuter l'outil.

Si vous ne spécifiez aucune base de données existante, une base de données et des fichiers journaux sont créés à l'emplacement par défaut de SQL Server. Une géodatabase est créée dans la base de données. Si vous choisissez une géodatabase de structure sde, un identifiant sde authentifié par SQL Server est créé, ainsi qu'un utilisateur de base de données et une structure.

Les messages relatifs à la création de la géodatabase sont consignés dans le fichier sde_setup.log, qui est créé 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 la création d'une géodatabase, consultez ce fichier pour le résoudre.

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'ArcGIS Desktop (Standard ou Advanced), ArcGIS Server ou ArcGIS Runtime (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 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 Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS 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, le fichier create_gdb.py est exécuté pour créer la base de données entgdb sur l'instance porthos\gisprod de SQL Server. L'outil est exécuté en tant qu'utilisateur sa, à l'aide de l'authentification de la base de données et il crée une géodatabase dans la structure de l'utilisateur sde. 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 SQL_SERVER -i porthos\gisprod -D entgdb --auth DATABASE_AUTH 
-U sa -P N0pe3king! --schema SDE_SCHEMA -u sde -p Tgdbst@rtsh3r3 -l \\Program Files\ESRI\License\sysgen\keycodes
```
Dans cet exemple, le même script est exécuté pendant la connexion à l'ordinateur client avec un identifiant de connexion associé à un membre du rôle de serveur fixe sysadmin pour créer une géodatabase dans la structure dbo :
```
create_gdb.py --DBMS SQL_SERVER -i porthos\gisprod -D entgdb --auth OPERATING_SYSTEM_AUTH 
--schema DBO_SCHEMA -l \\Program Files\ESRI\License\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 SQL Server.

Les messages relatifs à la création de la géodatabase sont consignés dans le fichier sde_setup.log, qui est créé dans le répertoire spécifié pour votre variable %TEMP% sur l'ordinateur sur lequel le script est exécuté. Si vous rencontrez un problème lors de la création d'une géodatabase, consultez ce fichier pour le résoudre.

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

L'administrateur de SQL Server 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, ce dernier peut créer la base de données et la structure, l'utilisateur et l'identifiant de connexion de l'administrateur de géodatabase. Si la géodatabase doit être stockée dans la structure sde, l'administrateur de base de données crée un utilisateur, une structure et un identifiant de connexion sde. Si la géodatabase doit être stockée dans la structure dbo, l'administrateur de base de données crée un identifiant de connexion et un utilisateur, puis il désigne ce dernier comme étant le propriétaire de la base de données. Pour en savoir plus sur les options de stockage de géodatabases, consultez la rubrique Comparaison entre propriétaires de géodatabase dans SQL Server.

L'administrateur de géodatabase peut se connecter à la base de données en tant qu'administrateur de géodatabase et créer une géodatabase à 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.

Installer et configurer le serveur SQL

Avant que l'administrateur de géodatabase ne crée une géodatabase, l'administrateur de SQL Server doit effectuer les opérations suivantes :

Installez SQL Server et configurez l'instance. La configuration de l'instance varie en fonction des besoins spécifiques de votre organisation. Vérifiez la configuration système requise d'ArcGIS avant de configurer une géodatabase pour vous assurer que le système de gestion de base de données, ArcGIS et le matériel que vous souhaitez utiliser sont bien pris en charge. Lorsque vous avez installé SQL Server, configurez l'instance SQL Server de sorte qu'elle accepte des connexions à distance. Par défaut, elles ne sont pas activées. Consultez la documentation Microsoft qui contient des informations sur l'installation et la configuration de SQL Server.
Créez une base de données.
Définit les options de la base de données SQL Server READ_COMMITTED_SNAPSHOT et ALLOW_SNAPSHOT_ISOLATION sur ON. Si l'administrateur SQL Server ne définit pas ces options sur ON, mais accorde les autorisations ALTER à l'administrateur de géodatabase dans la base de données, l'outil Activer une géodatabase d'entreprise change ces paramètres dans la base de données lors de l'exécution. Si l'administrateur SQL Server ne définit pas ces options et que l'administrateur de géodatabase ne dispose pas d'autorisations suffisantes pour les modifier, la création de la géodatabase échoue.
Ajoutez ou créez un identifiant de connexion correspondant à un utilisateur de base de données nommé sde ou à un utilisateur de base de données, également propriétaire de cette dernière.
Si vous utilisez une géodatabase de structure sde, créez une structure nommée sde dans la base de données. Elle sera la structure par défaut de l'utilisateur sde.
Si vous utilisez une géodatabase de structure sde, l'utilisateur sde doit disposer, au moins, des privilèges suivants : CREATE FUNCTION, CREATE PROCEDURE, CREATE TABLE et CREATE VIEW. Pour connaître les autres privilèges, consultez la rubrique Privilèges pour les géodatabases dans SQL Server.

Installer les clients

L'administrateur de géodatabase peut installer ArcGIS Desktop (Desktop Standard ou Desktop Advanced), d'ArcGIS Engine Runtime avec l'extension Geodatabase Update ou d'ArcGIS Server pour créer une géodatabase en exécutant un script Python. Pour exécuter l'outil de géotraitement Activer une géodatabase d'entreprise plutôt qu'un script, installez ArcGIS Desktop.

Dans la plupart des cas, vos clients ArcGIS sont installés sur un ordinateur autre que celui où SQL Server est installé. Ainsi, pour vous connecter à une base de données SQL Server, une version prise en charge du client SQL Server doit être installée sur l'ordinateur du client ArcGIS. Consultez la documentation Microsoft pour déterminer quelle version du client SQL Server vous devez installer pour vous connecter à la version de SQL Server que vous utilisez.

Installez le client ArcGIS à utiliser pour créer la géodatabase.

Suivez les instructions des guides d'installation du logiciel.
Installez un client SQL Server sur l'ordinateur du client ArcGIS.

Si vous installez le client SQL Server sur un système d'exploitation 64 bits, utilisez le fichier exécutable du client SQL Server 64 bits. Ce fichier exécutable installe le client 32 bits et 64 bits, ce qui lui permet de fonctionner avec des applications ArcGIS 32 bits, telles qu'ArcMap et des applications ArcGIS 64 bits, telles qu'ArcGIS Server ou ArcGIS Pro. Si vous exécutez le client SQL Server 32 bits sur un système d'exploitation 64 bits, il échouera.

Votre client ArcGIS est prêt à se connecter à la base de données et à créer une géodatabase. Utilisez une des méthodes décrites dans la section suivante.

Créer une géodatabase

L'administrateur de géodatabase peut exécuter l'outil Activer une géodatabase d'entreprise à partir d'ArcGIS Desktop ou exécuter un script Python à partir d'un client ArcGIS Desktop, ArcGIS 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.

Vous pouvez exécuter l'outil Activer une géodatabase d'entreprise à partir d'ArcGIS Desktop pour créer une géodatabase dans une base de données SQL Server.

Procédez comme suit pour créer une géodatabase à l'aide de l'outil Activer une géodatabase d'entreprise d'ArcMap :

Démarrez ArcMap ou ArcCatalog.
Connectez-vous à la base de données SQL Server à partir de l'arborescence du Catalogue, en tant qu'administrateur de géodatabase.

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 Server que vous avez créé lorsque vous avez autorisé ArcGIS Server et ajoutez-le à la zone de texte Fichier d'autorisation.

Lorsque vous utilisez l'assistant d'autorisation d'ArcGIS Server, un fichier de codes clés est écrit sur le serveur où le logiciel est installé. Le fichier de codes clés est créé dans Program Files\ESRI\License<release>\sysgen sur les serveurs Windows. Copiez le fichier dans un emplacement accessible avec l'outil Activer une géodatabase d'entreprise. Si vous ne l'avez pas déjà fait, autorisez ArcGIS 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.

Ensuite, l'administrateur de base de données peut créer 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 Server, ArcGIS Desktop ou ArcGIS Engine sur un ordinateur Windows, utilisez le script fourni ici.

Suivez les étapes ci-dessous pour exécuter un script Python permettant de créer une géodatabase dans une base de données SQL Server :

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

"""
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
"""

# 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 Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS 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'instance ssprod. 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 SQL_SERVER -i ssprod --auth DATABASE_AUTH 
-u sde -p Tgdbst@rtsh3r3 -D spdata -l \\Program Files\ESRI\License\sysgen\keycodes
```
Astuce:
Saisissez -h ou --help à l'invite de commande pour obtenir de l'aide sur la syntaxe.

Vous disposez maintenant d'une géodatabase dans la base de données SQL Server.

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 le script est exécuté.

Ensuite, l'administrateur de base de données peut créer un utilisateur autorisé à charger des données dans la géodatabase.