Einrichten einer Geodatabase in PostgreSQL unter Linux—Hilfe

Mit der Standard- oder Advanced-Lizenz verfügbar.

Sie sind der PostgreSQL- und Geodatabase-Administrator
Der PostgreSQL-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase

Die Art der Einrichtung einer Geodatabase hängt von der Situation vor Ort ab. Befolgen Sie die Anweisungen für die Szenarien, die auf Sie zutreffen.

Sie sind der PostgreSQL- und Geodatabase-Administrator.
Der PostgreSQL-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase.

Beachten Sie, dass dieses Thema sich auf PostgreSQL-Installationen auf einem Linux-Server bezieht. Wenn PostgreSQL auf einem Windows-Server installiert ist, finden Sie weitere Informationen unter Einrichten einer Geodatabase in PostgreSQL unter Windows.

Sie sind der PostgreSQL- und Geodatabase-Administrator

Wenn Sie sowohl Datenbank-Administrator als auch Geodatabase-Administrator sind und deshalb das Kennwort für beide Anmelderollen kennen, können Sie mit dem Geoverarbeitungswerkzeug oder Python-Skript Enterprise-Geodatabase erstellen eine Geodatabase in PostgreSQL erstellen.

Mit dem Werkzeug Enterprise-Geodatabase erstellen ist die Einrichtung einer Geodatabase völlig unkompliziert, da damit die Datenbankobjekte erstellt und die erforderlichen Berechtigungen für Sie gewährt werden. Um dies zu erreichen, werden bestimmte Standardeinstellungen verwendet. Im Folgenden wird beschrieben, welche Aufgaben vom Werkzeug Enterprise-Geodatabase erstellen ausgeführt und welche Einstellungen dabei verwendet werden:

Es wird eine Datenbank mit der PostgreSQL-Standardvorlage (template1) erstellt.
Wenn Sie die Datenbank mit einer anderen Vorlage erstellen müssen – z. B., wenn Sie die Vorlage "postgis" verwenden möchten –, müssen Sie die Datenbank vor der Ausführung dieses Werkzeugs erstellen. Danach können Sie das Werkzeug oder Skript Enterprise-Geodatabase erstellen ausführen und den Namen der zuvor erstellten Datenbank angeben.
Es wird eine Anmelderolle mit der Bezeichnung "sde" im Datenbank-Cluster erstellt, der Superuser-Status gewährt wird.
Der Benutzer "sde" muss ein Superuser sein, um die Geodatabase zu erstellen.
Es wird ein Schema mit dem Namen "sde" in der Datenbank erstellt.
Die Systemtabellen, Sichten, Funktionen und Prozeduren der Geodatabase werden im Schema "sde" gespeichert.
Der Benutzer "sde" wird als Besitzer des Schemas "sde" festgelegt, und der öffentlichen Rolle werden Verwendungsberechtigungen für das Schema "sde" gewährt.
Anmelderollen, die die Geodatabase verwenden, müssen auf das Schema "sde" zugreifen können. Da es wahrscheinlich noch keine Geodatabase-Anmelderollen gibt, gewährt dieses Werkzeug der Öffentlichkeit Verwendungsrechte. Nach der Erstellung der Geodatabase können Sie die Sicherheit Ihrer Geodatabase erhöhen, indem Sie die Verwendungsrechte für das Schema "sde" durch die Öffentlichkeit zurückziehen und nur den Anmeldegruppen und -rollen Verwendungsrechte gewähren, die Zugriff auf die Geodatabase benötigen.
Es wird eine Geodatabase erstellt.

Zunächst müssen Sie PostgreSQL installieren und den Datenbank-Cluster konfigurieren.

Einrichten von PostgreSQL

Befolgen Sie diese Schritte, um einen PostgreSQL-Datenbank-Cluster zum Speichern einer Geodatabase auf einem Linux-Server einzurichten:

Laden Sie eine unterstützte Version von PostgreSQL herunter, und installieren Sie diese. Konfigurieren Sie den Datenbank-Cluster.

Sie können PostgreSQL-Installationen von My Esri herunterladen. Wenn Sie diese Installation verwenden, sind keine speziellen nicht standardmäßigen Einstellungen erforderlich, um PostgreSQL mit ArcGIS zu verwenden. Ändern Sie nur das Gebietsschema und den Speicherort, wenn Sie dafür nicht die Standardeinstellungen verwenden möchten. Sie können auch eine separate Installation von PostgreSQL nutzen.

Lesen Sie die Dokumentation auf der PostgreSQL-Website bezüglich Anweisungen zum Installieren und Konfigurieren von PostgreSQL.
Konfigurieren Sie den Datenbank-Cluster, so dass dieser Verbindungen akzeptiert.

Hierzu müssen Sie u. a. die Datei "pg_hba.conf" so ändern, dass das Datenbank-Cluster Remote-Verbindungen zulässt.
Legen Sie die folgenden Umgebungsvariablen für den postgres-Benutzer fest, wenn diese nicht bereits korrekt definiert sind:
- PGDATA: Diese wurde normalerweise bereits bei der PostgreSQL-Installation festgelegt. Falls nicht, legen Sie dafür den Speicherort des PostgreSQL-Datenverzeichnisses fest. (Dieses befindet sich im PostgreSQL-Installationsverzeichnis.)
- LD_LIBRARY_PATH: Legen Sie für die Variable LD_LIBRARY_PATH das PostgreSQL-Verzeichnis "lib" fest. Der Speicherort des Verzeichnisses "lib" kann je nach Installation von PostgreSQL variieren. Um den richtigen Speicherort Ihrer PostgreSQL-Installation zu ermitteln, führen Sie "pg_config" als postgres-Benutzer aus. Legen Sie für LD_LIBRARY_PATH den Wert fest, der für PKGLIBDIR zurückgegeben wird.
- PATH: Legen Sie die Variable PATH so fest, dass diese "postgresql/bin" enthält.
Erstellen Sie im Datenbank-Cluster einen Tablespace, in dem die Datenbank gespeichert werden kann. Wenn Sie keinen Tablespace erstellen, wird der Tablespace "pg_default" verwendet.

Installieren und konfigurieren Sie als Nächstes einen ArcGIS-Client.

Konfigurieren eines ArcGIS-Clients

Sie können ein Python-Skript über ArcGIS for Desktop (Standard oder Advanced), ArcGIS Engine Runtime Geodatabase Update oder ArcGIS for Server ausführen, um eine Geodatabase zu erstellen. Wenn Sie das Geoverarbeitungswerkzeug Enterprise-Geodatabase erstellen anstelle eines Skripts ausführen möchten, verwenden Sie ArcGIS for Desktop.

ArcGIS for Desktop wird nur auf Windows-Betriebssystemen unterstützt und ist deshalb auf einem anderen Computer als PostgreSQL installiert. Sie können ArcGIS for Server auf demselben Computer wie PostgreSQL installieren. Da Datenbankmanagementsysteme jedoch viel Arbeitsspeicher belegen, wird dies nicht empfohlen.

Installieren Sie den ArcGIS-Client, von dem aus Sie die Geodatabase erstellen.

Normalerweise wird eine Geodatabase von ArcGIS for Server oder ArcGIS for Desktop (Standard oder Advanced) erstellt.
Wenn Sie ArcGIS for Server mit der Geodatabase in PostgreSQL verwenden, legen Sie die folgenden Variablen für das ArcGIS-Konto fest:
- SDEHOME: Legen Sie für diese Variable das ArcGIS for Server-Installationsverzeichnis fest.
  Wenn beispielsweise ArcGIS for Server im Standardverzeichnis auf einem Linux-Server installiert ist, legen Sie export SDEHOME=/home/ags/arcgis/server fest.
- PG_HOME: Legen Sie für PG_HOME "/opt/PostgreSQL/<Version>" fest.
  In diesem Beispiel wurde PG_HOME für eine PostgreSQL 9.2.2-Installation festgelegt: export PG_HOME=/opt/PostgreSQL/9.2.
- Wenn ArcGIS for Server auf einem Windows-Server installiert ist, fügen Sie die Verzeichnisse "PG_HOME\bin" und "SDEHOME\bin" zur PATH-Variable hinzu.
  Legen Sie unter Linux beispielsweise export PATH=$PATH:$PG_HOME/bin:$SDEHOME/bin fest.
- Wenn ArcGIS for Server auf einem Linux-Server installiert ist, fügen Sie der LD_LIBRARY_PATH-Variable "$PG_HOME/lib" und "$SDEHOME/lib" hinzu.
  Legen Sie beispielsweise export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PG_HOME/lib:$SDEHOME/lib fest.

Nachdem ArcGIS installiert ist, haben Sie Zugriff auf die Datei "st_geometry.so", die auf dem PostgreSQL-Server gespeichert werden muss.

Speichern der Datei "st_geometry.so"

Sie müssen die Datei "st_geometry.so" im PostgreSQL-Verzeichnis "lib" speichern, bevor Sie eine Geodatabase erstellen können. Der Speicherort des Verzeichnisses "lib" unter Linux kann je nach Installation von PostgreSQL variieren. Um den richtigen Speicherort Ihrer PostgreSQL-Installation zu ermitteln, führen Sie "pg_config" als postgres-Benutzer aus. Der für "PKGLIBDIR" zurückgegebene Wert ist das Verzeichnis "lib", in dem Sie die st_geometry-Bibliothek speichern können.

Die Dateien "st_geometry.so" werden mit den ArcGIS-Clients installiert. In der folgenden Tabelle wird angegeben, an welcher Stelle im ArcGIS-Client-Installationsverzeichnis sich die einzelnen Versionen der Bibliothek "st_geometry.so" befinden. Sie müssen die Bibliothek "st_geometry.so" verwenden, die der eingesetzten PostgreSQL-Version entspricht. Wenn Sie dem PostgreSQL-Verzeichnis "lib" nicht die richtige Bibliothek "st_geometry.so" hinzufügen, können Sie keine Geodatabase erstellen.

PostgreSQL-Version	ArcGIS-Client-Installationsverzeichnis
PostgreSQL 9.1	DatabaseSupport/PostgreSQL/9.1/Linux64
PostgreSQL 9.2	DatabaseSupport/PostgreSQL/9.2/Linux64
PostgreSQL 9.3	DatabaseSupport/PostgreSQL/9.3/Linux64

Verschieben Sie als Root-Benutzer die Bibliotheksdatei "st_geometry.so" vom ArcGIS-Verzeichnis "DatabaseSupport" in das PostgreSQL-Verzeichnis "lib".

Der Datenbank-Cluster und ArcGIS-Client sind einsatzbereit, sodass Sie eine Geodatabase erstellen können.

Erstellen einer Geodatabase

Sie können entweder das Werkzeug Enterprise-Geodatabase erstellen von ArcGIS for Desktop (Standard oder Advanced) oder ein Python-Skript von einem ArcGIS for Desktop (Standard oder Advanced)-, ArcGIS for Server- oder ArcGIS Engine-Client ausführen, um eine Geodatabase zu erstellen.

Ausführen des Werkzeugs Enterprise-Geodatabase erstellen

Wenn Sie Zugriff auf ArcGIS for Desktop haben, können Sie ein Geoverarbeitungswerkzeug ausführen, um die Geodatabase zu erstellen.

Starten Sie ArcMap oder ArcCatalog.
Öffnen Sie das Werkzeug Enterprise-Geodatabase erstellen.
Sie können dieses Werkzeug suchen oder zu diesem Werkzeug navigieren, das sich im Toolset "Geodatabase-Verwaltung" der Toolbox "Data Management" befindet.
Wählen Sie aus der Dropdown-Liste Datenbankplattform den Eintrag PostgreSQL aus.
Geben Sie im Textfeld Instanz den Namen des PostgreSQL-Servers ein.
Geben Sie im Textfeld Datenbank den Namen der Datenbank ein, in der die Geodatabase gespeichert werden soll.
Hinweis:
Geben Sie den Datenbanknamen in Kleinbuchstaben ein, da Objektnamen mit Großbuchstaben oder Groß- und Kleinbuchstaben für Geodatabases in PostgreSQL nicht unterstützt werden. Wenn Sie einen Datenbanknamen in Großschreibung oder in kombinierter Groß-/Kleinschreibung eingeben, wird er von ArcGIS in Kleinschreibung konvertiert.
Sie müssen die Verbindung zur Datenbank als Postgres-Superuser herstellen, um die Datenbank und andere Objekte erstellen zu können. Im Textfeld Datenbankadministrator wird daher standardmäßig postgres angezeigt. Wenn der Postgres-Superuser einen anderen Namen hat, geben Sie diesen Namen in das Textfeld Datenbankadministrator ein.
Geben Sie das Kennwort für den Postgres-Superuser in das Textfeld Datenbankadministrator-Kennwort ein.

Der Geodatabase-Administrator muss in PostgreSQL als "sde" bezeichnet werden. Daher ist das Textfeld Geodatabase-Administrator standardmäßig bereits mit sde ausgefüllt.

Geben Sie ein Kennwort für den Geodatabase-Administrator (SDE-Benutzer) in das Textfeld Geodatabase-Administratorkennwort ein.
Wenn im Datenbank-Cluster bereits ein SDE-Benutzer vorhanden ist, geben Sie das Kennwort des vorhandenen Benutzers ein. Es wird dann ein SDE-Schema in der Datenbank erstellt. Wenn der Benutzer noch nicht vorhanden ist, wird ein Benutzer mit dem Namen "sde" und dem von Ihnen angegebenen Kennwort im Datenbank-Cluster erstellt, und in der Datenbank wird ein entsprechendes Schema erstellt. Der öffentlichen Gruppenrolle wird Zugriff auf das SDE-Schema gewährt.
Tipp:
Wenn Sie das Schema nach dem Erstellen der Geodatabase sicherer machen möchten, können Sie der Gruppenrolle "public" die Nutzungsberechtigung entziehen. Erstellen Sie anschließend eine neue Gruppenrolle, gewähren Sie dieser Rolle Zugriff auf das SDE-Schema, und weisen Sie dann allen Anmelderollen, die auf die Geodatabase zugreifen müssen, diese Gruppenrolle zu.
Wenn Sie über einen vorkonfigurierten Tablespace verfügen, den Sie als standardmäßigen Tablespace für die Datenbank verwenden möchten, geben Sie seinen Namen in das Textfeld Tablespace-Name ein.
Mit diesem Werkzeug wird kein Tablespace erstellt. Sie müssen entweder einen vorhandenen Tablespace angeben oder das Textfeld leer lassen. Wenn Sie keinen Tablespace angeben, wird die Datenbank in "pg_default" erstellt.
Um eine Autorisierungsdatei anzugeben, wechseln Sie zu der Schlüsselcodedatei, die bei der Autorisierung von ArcGIS for Server erstellt wurde, und wählen Sie diese aus.
Diese Datei befindet sich im Ordner \\Program Files\ESRI\License<release#>\sysgen unter Windows und im Ordner/arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen unter Linux. Autorisieren Sie ArcGIS for Server jetzt, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.
Klicken Sie auf OK, um das Werkzeug auszuführen.
Zum Erstellen der Geodatabase wird eine Protokolldatei (GDBCreateGeodatabase<#>.log) in das Verzeichnis geschrieben, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Werkzeug ausgeführt wird.

Sie verfügen nun über eine Geodatabase in PostgreSQL.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Ausführen eines Python-Skripts

Sie können das hier verfügbare Skript kopieren, speichern und ausführen, um eine Geodatabase über einen ArcGIS for Desktop (Standard oder Advanced), ArcGIS for Server (Standard oder Advanced) oder dem ArcGIS Engine-Client (Geodatabase Update) zu erstellen.

Erstellen Sie eine Textdatei auf einem ArcGIS-Client-Computer, und kopieren Sie das folgende Skript in die Datei.

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

Speichern Sie die Datei mit der Erweiterung .py.
Führen Sie das Skript aus, indem Sie für Ihre Site spezifische Optionen und Informationen bereitstellen.
In der folgenden Beispielausführung von einem Linux-Computer wird die Datei "create_gdb.py" für einen Datenbank-Cluster mit dem Namen "pgprod" als Superuser "postgres" mit dem Kennwort "N0pe3king!" ausgeführt. Dabei werden eine Datenbank mit dem Namen "entgdb" in einem vorhandenen Tablespace mit dem Namen "gis" und die Anmelderolle "sde" mit dem Kennwort "Tgdbst@rtsh3r3 erstellt. Im Standardverzeichnis des ArcGIS-Servers wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.
```
./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
```
In diesem Beispiel wird dasselbe Skript auf einem Windows-Computer ausgeführt:
```
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
```
Tipp:
Geben Sie in der Eingabeaufforderung -h oder --help ein, um die Syntaxhilfe aufzurufen.

Sie verfügen nun über eine Geodatabase in PostgreSQL.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Der PostgreSQL-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase

Wenn die Person, die die Geodatabase erstellt, über keinen Zugriff auf das Kennwort des Datenbankadministrators (der Superuser "postgres") verfügt, kann der Datenbankadministrator die Datenbank einrichten. Danach kann der Geodatabase-Administrator über die Anmelderolle "sde" eine Verbindung mit der Datenbank herstellen und mit dem Geoverarbeitungswerkzeug oder Python-Skript Enterprise-Geodatabase aktivieren eine Geodatabase in der Datenbank erstellen.

Das Werkzeug Enterprise-Geodatabase aktivieren verwendet eine Datenbankverbindungsdatei als Eingabe und erstellt die Geodatabase-Systemtabellen, -sichten, -funktionen und -prozeduren im Schema "sde". Bevor das Werkzeug ausgeführt werden kann, muss der Datenbank-Administrator Folgendes einrichten:

Eine Anmelderolle mit dem Namen "sde" mit Superuser-Status
Eine Datenbank
Ein Schema "sde" in der Datenbank, dessen Besitzer die Anmelderolle "sde" ist
Die Bibliothek "st_geometry" muss sich im PostgreSQL-Installationsverzeichnis befinden

Einrichten von PostgreSQL

Zunächst muss der Datenbankadministrator PostgreSQL zum Speichern einer Geodatabase vorbereiten.

Die folgenden Anweisungen gelten für die Einrichtung des PostgreSQL-Datenbank-Clusters auf einem Linux-Server durch den Datenbank-Administrator. Beachten Sie, dass alle Datenbankobjektnamen (die Datenbank-, Schema- und Anmelderollen) nur Kleinbuchstaben enthalten dürfen.

Laden Sie eine unterstützte Version von PostgreSQL herunter, und installieren Sie diese. Konfigurieren Sie den Datenbank-Cluster.

Sie können PostgreSQL-Installationen von My Esri herunterladen. Wenn Sie diese Installation verwenden, sind keine speziellen nicht standardmäßigen Einstellungen erforderlich, um PostgreSQL mit ArcGIS zu verwenden. Ändern Sie nur das Gebietsschema und den Speicherort, wenn Sie dafür nicht die Standardeinstellungen verwenden möchten. Sie können auch eine separate Installation von PostgreSQL nutzen.

Lesen Sie die Dokumentation auf der PostgreSQL-Website bezüglich Anweisungen zum Installieren und Konfigurieren von PostgreSQL.
Konfigurieren Sie den Datenbank-Cluster, so dass dieser Verbindungen akzeptiert.

Hierzu müssen Sie u. a. die Datei "pg_hba.conf" so ändern, dass das Datenbank-Cluster Remote-Verbindungen zulässt.
Legen Sie die folgenden Umgebungsvariablen für den postgres-Benutzer fest, wenn diese nicht bereits korrekt definiert sind:
- PGDATA: Diese wurde normalerweise bereits bei der PostgreSQL-Installation festgelegt. Falls nicht, legen Sie dafür den Speicherort des PostgreSQL-Datenverzeichnisses fest. (Dieses befindet sich im PostgreSQL-Installationsverzeichnis.)
- LD_LIBRARY_PATH: Legen Sie für die Variable LD_LIBRARY_PATH das PostgreSQL-Verzeichnis "lib" fest. Der Speicherort des Verzeichnisses "lib" kann je nach Installation von PostgreSQL variieren. Um den richtigen Speicherort Ihrer PostgreSQL-Installation zu ermitteln, führen Sie "pg_config" als postgres-Benutzer aus. Legen Sie für LD_LIBRARY_PATH den Wert fest, der für PKGLIBDIR zurückgegeben wird.
- PATH: Legen Sie die Variable PATH so fest, dass diese "postgresql/bin" enthält.
Optional können Sie einen Tablespace in dem Datenbank-Cluster erstellen, in dem die Datenbank gespeichert werden kann.
Erstellen Sie eine Anmelderolle mit dem Namen "sde" mit Superuser-Status.

Tipp:

Wenn der Geodatabase-Administrator keine Datenbankverbindungen entfernt, können Sie den Superuser-Status von der Rolle "sde" zurücknehmen, nachdem die Datenbank erstellt wurde. Sie müssen ihn jedoch erneut gewähren, wenn die Geodatabase aktualisiert werden muss.
Erstellen Sie die Datenbank, in der die Geodatabase gespeichert wird.
Erstellen Sie in der Datenbank ein Schema mit dem Namen "sde", und autorisieren Sie die Anmelderolle für dieses Schema.
Darüber hinaus müssen Sie die Bibliotheksdatei "st_geometry.so" im PostgreSQL-Verzeichnis "lib" speichern. Diese Datei wird mit ArcGIS-Clients installiert. Fordern Sie den Geodatabase-Administrator auf, Ihnen die richtige Datei für die PostgreSQL-Installation zur Verfügung zu stellen, nachdem er den ArcGIS-Client installiert hat.

Nachdem die richtige Datei "st_geometry.so" zur Verfügung steht, legen Sie sie im PostgreSQL-Verzeichnis "lib" ab, während Sie als Root-Benutzer angemeldet sind. Beachten Sie, dass der Speicherort des Verzeichnisses "lib" unter Linux je nach Installation von PostgreSQL variieren kann. Um den richtigen Speicherort Ihrer PostgreSQL-Installation zu ermitteln, führen Sie "pg_config" als postgres-Benutzer aus. Der für "PKGLIBDIR" zurückgegebene Wert ist das Verzeichnis "lib", in dem Sie die st_geometry-Bibliothek speichern können.

Vorsicht:

Das Verzeichnis "DatabaseSupport" in ArcGIS for Server wird mit den Berechtigungen erstellt, die auf 700 festgelegt sind. Wenn Sie die mit ArcGIS for Server installierte Datei "st_geometry.so" verwenden, ändern Sie die Berechtigungen für die Datei auf 755 bei der Anmeldung als Root-Benutzer, um die Datei "st_geometry.so" in das PostgreSQL-Verzeichnis "lib" zu verschieben. Andernfalls kann der Benutzer "sde" nicht darauf zugreifen, um eine Geodatabase zu erstellen.
Händigen Sie dem Geodatabase-Administrator die Datenbankverbindungsinformationen aus.

Der Geodatabase-Administrator muss den Datenbank-Cluster-Namen, den Datenbanknamen und das Kennwort für die Anmelderolle "sde" kennen.

Nachdem eine Datenbank erstellt und konfiguriert wurde, kann der Geodatabase-Administrator einen ArcGIS-Client vorbereiten und eine Geodatabase erstellen.

Konfigurieren eines ArcGIS-Clients

Der Geodatabase-Administrator muss die folgenden Schritte ausführen, um die Erstellung einer Geodatabase vom ArcGIS-Client vorzubereiten:

Installieren Sie den ArcGIS-Client, von dem aus Sie die Geodatabase erstellen.

Normalerweise wird eine Geodatabase von ArcGIS for Server oder ArcGIS for Desktop (Standard oder Advanced) erstellt.

Nachdem der ArcGIS-Client installiert ist, können Sie auf die Datei "st_geometry.so" zugreifen, die der Datenbankadministrator zum Fertigstellen der Einrichtung des Datenbank-Clusters benötigt. Stellen Sie dem Datenbankadministrator die richtige Datei zur Verfügung.

In der folgenden Tabelle wird angegeben, an welcher Stelle im ArcGIS-Client-Installationsverzeichnis sich die einzelnen Versionen der Bibliothek "st_geometry.so" befinden. Sie müssen die Bibliothek "st_geometry.so" verwenden, die der eingesetzten PostgreSQL-Version, in der die Geodatabase erstellt wird, entspricht. Wenn die falsche Version der Bibliothek "st_geometry.so" im PostgreSQL-Verzeichnis "lib" abgelegt wird, können Sie keine Geodatabase erstellen.

PostgreSQL-Version	ArcGIS-Client-Installationsverzeichnis
PostgreSQL 9.1	DatabaseSupport/PostgreSQL/9.1/Linux64
PostgreSQL 9.2	DatabaseSupport/PostgreSQL/9.2/Linux64
PostgreSQL 9.3	DatabaseSupport/PostgreSQL/9.3/Linux64

Wenn Sie ArcGIS for Server mit der Geodatabase in PostgreSQL verwenden, legen Sie die folgenden Variablen für das ArcGIS-Konto fest:
- SDEHOME: Legen Sie für diese Variable das ArcGIS for Server-Installationsverzeichnis fest.
  Wenn beispielsweise ArcGIS for Server im Standardverzeichnis auf einem Linux-Server installiert ist, legen Sie export SDEHOME=/home/ags/arcgis/server fest.
- PG_HOME: Legen Sie für PG_HOME "/opt/PostgreSQL/<Version>" fest.
  In diesem Beispiel wurde PG_HOME für eine PostgreSQL 9.2.2-Installation festgelegt: export PG_HOME=/opt/PostgreSQL/9.2.
- Wenn ArcGIS for Server auf einem Windows-Server installiert ist, fügen Sie die Verzeichnisse PG_HOME\bin und SDEHOME\bin zur PATH-Variable hinzu.
  Legen Sie unter Linux beispielsweise export PATH=$PATH:$PG_HOME/bin:$SDEHOME/bin fest.
- Wenn ArcGIS for Server auf einem Linux-Server installiert ist, fügen Sie der LD_LIBRARY_PATH-Variable "$PG_HOME/lib" und "$SDEHOME/lib" hinzu.
  Legen Sie beispielsweise export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PG_HOME/lib:$SDEHOME/lib fest.

Der ArcGIS-Client ist bereit und kann eine Verbindung zur Datenbank herstellen und eine Geodatabase erstellen.

Erstellen einer Geodatabase

Der Geodatabase-Administrator kann entweder das Werkzeug Enterprise-Geodatabase aktivieren von ArcGIS for Desktop (Standard oder Advanced) oder ein Python-Skript von einem ArcGIS for Desktop-, ArcGIS for Server- oder ArcGIS Engine-Client ausführen, um eine Geodatabase in der vorhandenen Datenbank zu erstellen.

Führen Sie das Werkzeug Enterprise-Geodatabase aktivieren aus.

Wenn Sie Zugriff auf ArcGIS for Desktop haben, können Sie ein Geoverarbeitungswerkzeug ausführen, um die Geodatabase zu erstellen.

Starten Sie ArcMap oder ArcCatalog.
Stellen Sie vom Kataloginhaltsverzeichnis mit der Anmelderolle "sde" eine Verbindung mit der PostgreSQL-Datenbank her.
Vergessen Sie nicht, das Kennwort des Benutzers im Dialogfeld Datenbankverbindung zu speichern.
Klicken Sie mit der rechten Maustaste auf die Datenbankverbindung und wählen Sie Geodatabase aktivieren.
Das Werkzeug Enterprise-Geodatabase aktivieren wird geöffnet, und im Textfeld Eingabe-Datenbankverbindung wird der Name und Speicherort der Verbindungsdatei eingefügt.
Navigieren Sie zu der ArcGIS for Server-Autorisierungsdatei, die bei der Autorisierung von ArcGIS for Server erstellt wurde, und fügen Sie sie dem Textfeld Autorisierungsdatei hinzu.
Wenn Sie zum Autorisieren von ArcGIS for Server den Assistenten verwenden, wird eine Schlüsselcodedatei auf dem Server erzeugt, auf dem die Software installiert ist. Wenn Sie ArcGIS for Server auf einem Linux-System autorisiert haben, wurde die Schlüsselcode-Datei im Verzeichnis /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release>/sysgen erstellt. Wenn Sie die Autorisierung auf einem Windows-Server ausgeführt haben, wurde die Datei im Verzeichnis Program Files\ESRI\License<release>\sysgen erstellt. Autorisieren Sie ArcGIS for Server, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.
Klicken Sie auf OK, um das Werkzeug auszuführen.

Es wird eine Geodatabase in der Datenbank erstellt.

Zum Erstellen der Geodatabase wird eine Protokolldatei (GDBCreateGeodatabase<#>.log) in das Verzeichnis geschrieben, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Werkzeug ausgeführt wird. Falls Sie Probleme beim Ausführen des Werkzeugs haben, überprüfen Sie diese Protokolldatei, um das Problem zu beheben.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Ausführen eines Python-Skripts

Wenn Sie die Geodatabase durch das Ausführen eines Skripts von einer ArcGIS for Server-, ArcGIS for Desktop (Standard oder Advanced)- oder ArcGIS Engine-Installation erstellen möchten, können Sie das hier verfügbare Skript dazu verwenden.

Erstellen Sie eine Textdatei auf einem ArcGIS for Server-Computer, und kopieren Sie das folgende Skript in die Datei.

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

Speichern Sie die Datei mit der Erweiterung .py.
Führen Sie das Skript aus, indem Sie für Ihre Site spezifische Optionen und Informationen bereitstellen.
Im folgenden Beispiel wird die Datei "enable_gdb.py" für die Datenbank "spdata" auf dem Datenbank-Cluster "pgprod" ausgeführt. Die Verbindung wird als SDE-Anmeldung mit dem Kennwort "Tgdbst@rtsh3r3" hergestellt. Im Standardverzeichnis des ArcGIS-Servers wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.
```
./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
```
Tipp:
Geben Sie in der Eingabeaufforderung -h oder --help ein, um die Syntaxhilfe aufzurufen.

Sie verfügen nun über eine Geodatabase in PostgreSQL.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.