Créer une géodatabase dans SQL Server

Disponible avec une licence Standard ou Advanced.

Pour créer une géodatabase dans une base de données Microsoft SQL Server, vous exécutez un outil de géotraitement ou un script Python à partir d’un client ArcGIS. Commencez par lire les conditions préalables, puis conformez-vous aux instructions qui s’appliquent à votre situation.

Conditions préalables

Pour créer une géodatabase SQL Server, procédez comme suit :

  1. Vérifiez que les combinaisons de ArcGIS, de SQL Server et des systèmes d’exploitation que vous voulez utiliser sont compatibles.
  2. Téléchargez le client ODBC SQL Server requis pour se connecter à la version de SQL Server que vous allez utiliser pour stocker votre géodatabase.
  3. Procurez-vous un fichier de codes clés ArcGIS Server et placez-le dans un emplacement accessible depuis le client ArcGIS que vous allez utiliser pour créer la géodatabase.
  4. Déterminez la personne qui crée la géodatabase car cela affecte la personne qui crée la base de données ainsi que l’outil permettant de créer la géodatabase. Suivez les instructions correspondant à votre situation :

Vous êtes l’administrateur de SQL Server et de la géodatabase

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 Create Enterprise Geodatabase (Créer une géodatabase d’entreprise) ou un script Python pour créer une géodatabase dans une base de données 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. Pour ce faire, l’outil utilise les paramètres par défaut suivants et crée les objets de base de données suivants :

  • 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.
  • Il utilise les tailles de fichier de base de données par défaut que vous avez définies pour le modèle de base de données SQL Server ou 500 Mo pour le fichier MDF et 125 Mo pour le fichier LDF, la valeur la plus élevée étant retenue.
  • Si vous créez une géodatabase dans une structure nommée sde, l’outil crée un identifiant de connexion sde authentifié par la base de données 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 à mettre fin aux connexions à l’instance SQL Server.
  • Il crée les objets de géodatabase dans l’instance SQL Server.

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

Installer et configurer SQL Server

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 assemblage insensible à la casse.

Une fois SQL Server installé (par le service informatique ou vous-même), 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 avec l’extension de géodatabase, ou ArcGIS Server (Enterprise Edition) et exécuter un script Python depuis l’un ou l’autre 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.

Remarque :

Vous avez besoin d'un fichier de codes clés ArcGIS Server (édition Enterprise) pour autoriser votre géodatabase dans la section suivante. Même si vous n'exécutez pas de script Python à partir d'un ordinateur ArcGIS Server pour créer la géodatabase, installez et autorisez ArcGIS Server pour obtenir le fichier de codes clés. Vous devrez peut-être copier le fichier de codes clés de l'ordinateur ArcGIS Server vers un emplacement auquel l'outil de géotraitement Créer la géodatabase d'entreprise peut accéder.

Dans la plupart des cas, vos clients ArcGIS sont installés sur un ordinateur autre que celui où SQL Server est installé. Ainsi, vous devez disposer d’un client SQL Server pris en charge installé sur la machine cliente ArcGIS pour vous connecter à la base de données. Reportez-vous à la rubrique Configuration système requise de ArcGIS pour SQL Server pour déterminer la version du client SQL Server que vous devez installer pour vous connecter à la version de SQL Server utilisée.

Pour vous connecter à SQL Server sur une machine Microsoft Windows, vous pouvez télécharger le client SQL Server depuis My Esri ou depuis le Centre de téléchargement Microsoft. Pour vous connecter à SQL Server sur une machine Linux, téléchargez les fichiers du client SQL Server à partir du Centre de téléchargement Microsoft. Suivez les instructions de Microsoft pour installer le client SQL Server sur votre ordinateur client.

Suivez ces étapes pour installer et configurer le client dont vous avez besoin pour créer la géodatabase. Si vous n’êtes pas autorisé à installer le logiciel, demandez à votre service informatique de suivre ces étapes.

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

    Suivez les instructions des guides d'installation du logiciel.

  2. 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 les clients 32 bits et 64 bits, ce qui lui permet de fonctionner avec des applications ArcGIS 32 bits, telles que ArcMap, et des applications ArcGIS 64 bits, telles que ArcGIS Server ou ArcGIS Pro. Si vous exécutez le client SQL Server 32 bits sur un système d’exploitation 64 bits, l’installation échoue.

Vous pouvez maintenant créer une géodatabase.

Créer une géodatabase

Vous pouvez exécuter l’outil Create Enterprise Geodatabase (Créer une géodatabase d’entreprise) depuis 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'ArcGIS Pro :

  1. Démarrez ArcGIS Pro.
  2. 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.

  3. Sélectionnez SQL Server dans la liste déroulante Plateforme de la base de données.
  4. Saisissez le nom de l’instance SQL Server à laquelle vous allez vous connecter dans la zone de texte Instance.
  5. 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, l’outil la crée. Si la base de données existe, l’outil l’utilise pour stocker la géodatabase.

  6. 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 utilisateur sysadmin.
    • 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.
  7. 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.

  8. Si vous choisissez une structure détenue par un utilisateur sde, la zone de texte Geodatabase Administrator (Administrateur de la géodatabase) indique déjà sde. S’il n’existe aucun utilisateur de ce nom, l’outil le crée ainsi que la structure correspondante et lui accorde les privilèges requis pour créer une géodatabase.

    Si vous utilisez l’authentification de base de données et une structure dbo pour stocker la géodatabase, saisissez le nom d’un utilisateur dbo dans l’instance SQL Server dans la zone de texte Geodatabase Administrator (Administrateur de la 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 que vous puissiez créer une géodatabase à structure dbo.

  9. 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 modifie pas le mot de passe.

  10. 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 est créé dans le dossier \\Program Files\ESRI\License<release#>\sysgen sur les serveurs Windows et dans /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen sur les serveurs Linux. 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.

  11. Cliquez sur Run (Exécuter).

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 la base de données 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 depuis ArcGIS Desktop (Standard ou Advanced), ArcGIS Server ou ArcGIS Engine (avec l’extension Geodatabase).

  1. 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=['SQL_SERVER', 'ORACLE', 'POSTGRESQL', ''], default="", help="Type of enterprise DBMS:  SQL_SERVER, 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 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 ==""):	
    		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)
  2. Enregistrez le fichier avec l'extension .py.
  3. 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 :

    Type -h or --help at the command prompt to get syntax help.

Vous disposez maintenant d’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 ; 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éodatabase, 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 SQL Server

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 de ArcGIS pour vous assurer que le système de gestion de bases de données, ArcGIS et le matériel que vous souhaitez utiliser sont bien pris en charge. Une fois SQL Server installé, 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éfinissez 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 Enable Enterprise Geodatabase (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 des 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), ArcGIS Engine avec l’extension Geodatabase, ou 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.

Remarque :

Vous avez besoin d'un fichier de codes clés ArcGIS Server (édition Enterprise) pour autoriser votre géodatabase dans la section suivante. Même si vous n'exécutez pas de script Python à partir d'un ordinateur ArcGIS Server pour créer la géodatabase, vous devez installer et autoriser ArcGIS Server pour obtenir le fichier de codes clés. Vous devrez peut-être copier le fichier de codes clés de l'ordinateur ArcGIS Server vers un emplacement auquel l'outil de géotraitement Activer une géodatabase d'entreprise peut accéder.

Dans la plupart des cas, vos clients ArcGIS sont installés sur un ordinateur autre que celui où SQL Server est installé. Ainsi, vous devez disposer d’un client SQL Server pris en charge installé sur la machine cliente ArcGIS pour vous connecter à la base de données. Reportez-vous à la rubrique Configuration système requise de ArcGIS pour SQL Server pour déterminer la version du client SQL Server que vous devez installer pour vous connecter à la version de SQL Server utilisée.

Pour vous connecter à SQL Server sur une machine Microsoft Windows, vous pouvez télécharger le client SQL Server depuis My Esri ou depuis le Centre de téléchargement Microsoft. Pour vous connecter à SQL Server sur une machine Linux, téléchargez les fichiers du client SQL Server à partir du Centre de téléchargement Microsoft. Suivez les instructions de Microsoft pour installer le client SQL Server sur votre ordinateur client.

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

    Suivez les instructions des guides d'installation du logiciel.

  2. 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 les clients 32 bits et 64 bits, ce qui lui permet de fonctionner avec des applications ArcGIS 32 bits, telles que ArcMap, et des applications ArcGIS 64 bits, telles que ArcGIS Server ou ArcGIS Pro. Si vous exécutez le client SQL Server 32 bits sur un système d’exploitation 64 bits, il échoue.

Votre client ArcGIS est prêt à se connecter à la base de données et à créer une géodatabase. Pour ce faire, utilisez l’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 Enable Enterprise Geodatabase (Activer une géodatabase d’entreprise) depuis ArcGIS Desktop (Standard ou Avanced) ou exécuter un script Python depuis un client ArcGIS Desktop (Standard ou Advanced), ArcGIS Server ou ArcGIS Engine avec l’extension Geodatabase 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 Enable Enterprise Geodatabase (Activer une géodatabase d’entreprise) depuis ArcGIS Desktop pour créer une géodatabase dans une base de données SQL Server existante.

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

  1. Démarrez ArcGIS Pro.
  2. Connectez-vous à la base de données SQL Server en tant qu’administrateur de la 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.

  3. Ouvrez l'outil Activer une géodatabase d'entreprise.
  4. Faites glisser votre nouvelle connexion à la base de données dans le champ Connexion à la géodatabase en entrée.
  5. 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 de clés est créé dans Program Files\ESRI\License<release>\sysgen sur les serveurs Windows et dans /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen sur les serveurs Linux. 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.

  6. Cliquez sur Run (Exécuter).

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

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

Si vous souhaitez créer la géodatabase en exécutant un script depuis une installation ArcGIS Server, ArcGIS Desktop (Standard ou Advanced) ou ArcGIS Engine avec l’extension Geodatabase sur une machine Windows, vous pouvez utiliser 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 existante :

  1. 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=['SQL_SERVER', 'ORACLE', 'POSTGRESQL', 'DB2','INFORMIX','DB2ZOS', ''], default="", help="Type of enterprise DBMS:  SQL_SERVER, 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)
    
    		
    	# 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)

  2. Enregistrez le fichier avec l'extension .py.
  3. 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 ArcGIS Server par défaut 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 :

    Type -h or --help at the command prompt to get syntax help.

La base de données SQL Server contient maintenant une géodatabase.

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.