Tutorial: Bereitstellen von SAP Deployment Automation Framework für Unternehmen

Artikel
03/15/2024

In diesem Tutorial erfahren Sie, wie Sie Bereitstellungen mithilfe von SAP Deployment Automation Framework durchführen. In diesem Beispiel wird Azure Cloud Shell verwendet, um die Infrastruktur der Steuerungsebene bereitzustellen. Der virtuelle Bereitstellungscomputer (VM) erstellt die verbleibende Infrastruktur und SAP HANA Konfigurationen.

In diesem Tutorial führen Sie die folgenden Aufgaben aus:

Die Steuerungsebene (Deployer-Infrastruktur und Bibliothek) bereitstellen.
Die Workloadzone (Landschaft und System) bereitstellen.
Hoch- und Herunterladen von Stücklisten
Konfigurieren Sie Standard- und SAP-spezifische Betriebssystemeinstellungen.
Die HANA-Datenbank installieren.
Installieren Sie den SAP Central Services (SCS)-Server.
Die HANA-Datenbank laden.
Den primären Anwendungsserver installieren.

Es gibt drei Hauptschritte einer SAP-Bereitstellung mit dem Automatisierungsframework in Azure:

Vorbereiten der Region Hierzu stellen Sie Komponenten für die Unterstützung des SAP-Automatisierungsframeworks in einer angegebenen Azure-Region bereit. In diesem Schritt führen Sie Folgendes aus:
1. Sie erstellen die Bereitstellungsumgebung.
2. Sie erstellen den freigegebenen Speicher für Terraform-Zustandsdateien.
3. Sie erstellen den freigegebenen Speicher für das SAP-Installationsmedium.
Vorbereiten der Workloadzone Hierzu stellen Sie die Workloadzonenkomponenten wie das virtuelle Netzwerk und Key Vaults bereit.
Bereitstellen des Systems. Hierzu stellen Sie die Infrastruktur für das SAP-System bereit.

Es gibt mehrere Arbeitsabläufe im Automatisierungsprozess der Bereitstellung. Dieses Tutorial konzentriert sich auf einen bestimmten Workflow, der die Bereitstellung erleichtert. Sie können diesen Workflow, die eigenständige S4 HANA-Umgebung von SAP, mithilfe von Bash bereitstellen. In diesem Tutorial werden die allgemeine Hierarchie und die verschiedenen Phasen der Bereitstellung beschrieben.

Übersicht über die Umgebung

SAP Deployment Automation Framework verfügt über zwei Standardkomponenten:

Infrastruktur für die Bereitstellung (Kontrollebene)
SAP-Infrastruktur (SAP-Workload)

Das folgende Diagramm zeigt die Abhängigkeit zwischen der Steuerungsebene und der Anwendungsebene.

Diagram that shows the DevOps tutorial infrastructure design.

Das Framework verwendet Terraform für die Bereitstellung der Infrastruktur und Ansible für die Konfiguration des Betriebssystems und der Anwendung. Das folgende Diagramm zeigt die logische Trennung von Steuerungsebene und Workloadzone.

Diagram that shows the SAP Deployment Automation Framework environment.

Verwaltungszone

Die Verwaltungszone enthält die Infrastruktur der Steuerungsebene, aus der andere Umgebungen bereitgestellt werden. Nach dem Bereitstellen der Verwaltungszone bedarf es äußerst selten einer erneuten Bereitstellung.

Diagram that shows the control plane.

Der Bereitsteller ist die Ausführungs-Engine des SAP-Automatisierungsframeworks. Diese vorkonfigurierte VM wird zum Ausführen von Terraform- und Ansible-Befehlen verwendet.

Die SAP-Bibliothek stellt den beständigen Speicher für die Terraform-Zustandsdateien und die heruntergeladenen SAP-Installationsmedien für die Steuerungsebene bereit.

Den Bereitsteller und die Bibliothek konfigurieren Sie in einer Terraform-.tfvars-Variablendatei. Weitere Informationen finden Sie unter Konfigurieren der Steuerungsebene.

Workloadzone

Eine SAP-Anwendung verfügt in der Regel über mehrere Bereitstellungsebenen. Beispielsweise können Sie über Entwicklungs-, Qualitätssicherungs- und Produktionsebenen verfügen. In SAP Deployment Automation Framework werden diese Ebenen als Workloadzonen bezeichnet.

Diagram that shows the workload zone.

Die SAP-Workloadzone enthält die Netzwerkkomponenten und die freigegebenen Komponenten für die SAP-VMs. Zu diesen Komponenten gehören Routingtabellen, Netzwerksicherheitsgruppen und virtuelle Netzwerke. Diese Landschaft bietet die Möglichkeit, Bereitstellungen in verschiedene Umgebungen zu unterteilen. Weitere Informationen finden Sie unter Konfigurieren der Workloadzone.

Die Systembereitstellung besteht aus den VMs, auf denen die SAP-Anwendung ausgeführt werden soll, einschließlich der Web-, App- und Datenbankebenen. Weitere Informationen finden Sie unter Konfigurieren des SAP-Systems.

Voraussetzungen

Das Repository von SAP Deployment Automation Framework ist auf GitHub verfügbar.

Sie müssen Azure Bastion bereitstellen oder einen SSH-Client (Secure Shell) verwenden, um eine Verbindung zum Deployer herzustellen. Verwenden Sie einen beliebigen SSH-Client, mit dem Sie sich wohl fühlen.

Überprüfen des Azure-Abonnementkontingents

Stellen Sie sicher, dass Ihr Microsoft Azure-Abonnement über ein ausreichendes Kernangebot für SKUs der Familien DdSV4 und EdsV4 in der gewählten Region verfügt. Für jede VM-Familie sollten etwa 50 verfügbare Kerne ausreichen.

S-Benutzerkonto für SAP-Softwaredownload

Zum Herunterladen der SAP-Software ist ein gültiges SAP-Benutzerkonto (SAP-Benutzer- oder S-Benutzerkonto) mit Softwaredownloadberechtigungen erforderlich.

Einrichten von Cloud Shell

Wechseln Sie zu Azure Cloud Shell.
Melden Sie sich bei Ihrem Azure-Konto an.
```
az login
```
Authentifizieren Sie Ihre Anmeldung. Schließen Sie das Fenster erst, wenn Sie dazu aufgefordert werden.

Überprüfen Sie, ob Ihr Abonnement aktiv ist, und geben Sie Ihre Abonnement-ID an:

az account list --query "[?isDefault].{Name: name, CloudName: cloudName, SubscriptionId: id, State: state, IsDefault: isDefault}" --output=table

Oder:

az account list --output=table | grep True

Ändern Sie bei Bedarf Ihr aktives Abonnement.

az account set --subscription <Subscription ID>

Überprüfen Sie, ob Ihr aktives Abonnement geändert wurde.

az account list --query "[?isDefault].{Name: name, CloudName: cloudName, SubscriptionId: id, State: state, IsDefault: isDefault}" --output=table

Entfernen Sie optional alle Bereitstellungsartefakte. Verwenden Sie diesen Befehl, wenn Sie alle Reste vorheriger Bereitstellungsartefakte entfernen möchten.
```
cd ~

rm -rf Azure_SAP_Automated_Deployment .sap_deployment_automation .terraform.d
```

Erstellen Sie den Bereitstellungsordner, und klonen Sie das Repository.

mkdir -p ${HOME}/Azure_SAP_Automated_Deployment; cd $_

git clone https://github.com/Azure/sap-automation-bootstrap.git config

git clone https://github.com/Azure/sap-automation.git sap-automation

git clone https://github.com/Azure/sap-automation-samples.git samples

cp -Rp samples/Terraform/WORKSPACES ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES

Überprüfen Sie optional die Versionen von Terraform und die Azure CLI, die auf Ihrer Cloud Shell-Instanz verfügbar sind.
```
./sap-automation/deploy/scripts/helpers/check_workstation.sh
```
Aktualisieren Sie auf die folgenden Versionen, um das Automatisierungsframework ausführen zu können:
- az-Version 2.5.0 oder höher
- terraform-Version 1.5 oder höher Führen Sie bei Bedarf ein Upgrade mithilfe der Terraform-Anweisungen durch.

Erstellen eines Dienstprinzipals

Das SAP Automatisierungs-Bereitstellungs-Framework verwendet Dienstprinzipale für die Bereitstellung. Erstellen Sie einen Dienstprinzipal für Ihre Bereitstellung der Steuerungsebene. Stellen Sie sicher, dass Sie ein Konto mit Berechtigungen zum Erstellen von Dienstprinzipals verwenden.

Wenn Sie den Namen für Ihren Dienstprinzipal auswählen, stellen Sie sicher, dass der Name innerhalb Ihres Azure-Mandanten eindeutig ist.

Erteilen Sie dem Dienstprinzipal Berechtigungen als Mitwirkender und Benutzerzugriffsadministrator.

export    ARM_SUBSCRIPTION_ID="<subscriptionId>"
export control_plane_env_code="LAB"

az ad sp create-for-rbac --role="Contributor"           \
  --scopes="/subscriptions/${ARM_SUBSCRIPTION_ID}"      \
  --name="${control_plane_env_code}-Deployment-Account"

Überprüfen Sie die Ausgabe. Beispiel:

{
    "appId": "<AppId>",
    "displayName": "<environment>-Deployment-Account ",
    "name": "<AppId>",
    "password": "<AppSecret>",
    "tenant": "<TenantId>"
}

Kopieren Sie die Ausgabedetails. Speichern Sie die Werte für appId, password, und Tenant.

Die Ausgabe wird mit den folgenden Parametern angezeigt. Sie verwenden diese Parameter in späteren Schritten mit Automatisierungsbefehlen.

Parameter-Eingabename Ausgabename

spn_id appId

spn_secret password

tenant_id tenant

Parameter-Eingabename	Ausgabename
`spn_id`	`appId`
`spn_secret`	`password`
`tenant_id`	`tenant`

Weisen Sie optional dem Dienstprinzipal die Rolle Benutzerzugriffsadministrator zu.

export appId="<appId>"

az role assignment create --assignee ${appId}   \
  --role "User Access Administrator"            \
  --scope /subscriptions/${ARM_SUBSCRIPTION_ID}

Wichtig

Wenn Sie dem Dienstprinzipal nicht die Rolle Benutzerzugriffsadministrator zuweisen, können Sie keine Berechtigungen mithilfe der Automatisierung zuweisen.

Konfigurieren der Anmeldeinformationen für die Webanwendung der Steuerungsebene

Als Teil der Steuerungsebene des SAP-Automatisierungsframeworks können Sie optional eine interaktive Webanwendung erstellen, die Sie bei der Erstellung der erforderlichen Konfigurationsdateien unterstützt.

Screenshot that shows the web app front page.

Erstellen einer App-Registrierung

Wenn Sie die Web-App verwenden wollen, müssen Sie zunächst eine App-Registrierung zu Authentifizierungszwecken erstellen. Öffnen Sie Cloud Shell und führen Sie die folgenden Befehle aus:

Ersetzen Sie LAB bei Bedarf durch Ihre Umgebung.

export            env_code="LAB"
 
 
echo '[{"resourceAppId":"00000003-0000-0000-c000-000000000000","resourceAccess":[{"id":"e1fe6dd8-ba31-4d61-89e7-88639da4683d","type":"Scope"}]}]' >> manifest.json
 
export TF_VAR_app_registration_app_id=$(az ad app create \
    --display-name ${env_code}-webapp-registration       \
    --enable-id-token-issuance true                      \
    --sign-in-audience AzureADMyOrg                      \
    --required-resource-access @manifest.json            \
    --query "appId" --output tsv )
 
#remove the placeholder manifest.json
rm manifest.json
 
export TF_VAR_webapp_client_secret=$(az ad app credential reset \
    --id $TF_VAR_app_registration_app_id --append               \
    --query "password" --output tsv )
 
export TF_use_webapp=true
 
 
echo "App registration ID:  ${TF_VAR_app_registration_app_id}"
echo "App registration password:  ${TF_VAR_webapp_client_secret}"

Hinweis

Stellen Sie sicher, dass Sie mit einem Benutzerkonto angemeldet sind, das über die erforderlichen Berechtigungen zum Erstellen von Anwendungsregistrierungen verfügt. Weitere Informationen zu App-Registrierungen finden Sie unter Erstellen einer App-Registrierung.

Kopieren Sie die Ausgabedetails. Speichern Sie die Werte für App registration ID und App registration password.

Die Ausgabe wird mit den folgenden Parametern angezeigt. Sie verwenden diese Parameter in späteren Schritten mit Automatisierungsbefehlen.

Parameter-Eingabename	Ausgabename
`app_registration_app_id`	`App registration ID`
`webapp_client_secret`	`App registration password`

Konfigurationsdateien ansehen

Öffnen Sie Visual Studio Code über Cloud Shell.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
code .

Erweitern Sie das WORKSPACES-Verzeichnis. Es gibt sechs Unterordner: CONFIGURATION, DEPLOYER, LANDSCAPE, LIBRARY, SYSTEM und BOMS. Erweitern Sie jeden dieser Ordner, um nach Konfigurationsdateien für die regionale Bereitstellung zu suchen.

Suchen Sie die Terraform-Variablendateien im entsprechenden Unterordner. Ein Beispiel für die Terraform-DEPLOYER-Variablendatei könnte folgendermaßen aussehen:

# The environment value is a mandatory field, it is used for partitioning the environments, for example, PROD and NP.
environment = "LAB"
# The location/region value is a mandatory field, it is used to control where the resources are deployed
location = "swedencentral"

# management_network_address_space is the address space for management virtual network
management_network_address_space = "10.10.20.0/25"
# management_subnet_address_prefix is the address prefix for the management subnet
management_subnet_address_prefix = "10.10.20.64/28"

# management_firewall_subnet_address_prefix is the address prefix for the firewall subnet
management_firewall_subnet_address_prefix = "10.10.20.0/26"
firewall_deployment = true

# management_bastion_subnet_address_prefix is the address prefix for the bastion subnet
management_bastion_subnet_address_prefix = "10.10.20.128/26"
bastion_deployment = true

# deployer_enable_public_ip controls if the deployer Virtual machines will have Public IPs
deployer_enable_public_ip = true

# deployer_count defines how many deployer VMs will be deployed
deployer_count = 1

# use_service_endpoint defines that the management subnets have service endpoints enabled
use_service_endpoint = true

# use_private_endpoint defines that the storage accounts and key vaults have private endpoints enabled
use_private_endpoint = false

# enable_firewall_for_keyvaults_and_storage defines that the storage accounts and key vaults have firewall enabled
enable_firewall_for_keyvaults_and_storage = false

# public_network_access_enabled controls if storage account and key vaults have public network access enabled
public_network_access_enabled = true

Notieren Sie die Terraform-Variablendateispeicherorte für zukünftige Bearbeitungen während der Bereitstellung.

Suchen Sie die Terraform-Variablendateien für die SAP-Bibliothek im entsprechenden Unterordner. Ein Beispiel für die Terraform-LIBRARY-Variablendatei könnte folgendermaßen aussehen:

# The environment value is a mandatory field, it is used for partitioning the environments, for example, PROD and NP.
environment = "LAB"
# The location/region value is a mandatory field, it is used to control where the resources are deployed
location = "swedencentral"

#Defines the DNS suffix for the resources
dns_label = "lab.sdaf.contoso.net"

# use_private_endpoint defines that the storage accounts and key vaults have private endpoints enabled
use_private_endpoint = false

Notieren Sie die Terraform-Variablendateispeicherorte für zukünftige Bearbeitungen während der Bereitstellung.

Wichtig

Stellen Sie sicher, dass dns_label mit Ihrer Instanz von Azure Private DNS übereinstimmt.

Bereitstellen der Steuerungsebene

Verwenden Sie das Skript deploy_controlplane.sh, um den Bereitsteller und die Bibliothek bereitzustellen. Diese Bereitstellungsteile bilden die Steuerungsebene für einen ausgewählten Automatisierungsbereich.

Die Bereitstellung durchläuft die folgenden Zyklen: Bereitstellen der Infrastruktur, Aktualisierung des Zustands und Hochladen der Terraform-Zustandsdateien in das Speicherkonto der Bibliothek. Alle diese Schritte werden in einem einzigen Bereitstellungsskript zusammengefasst. Das Skript benötigt den Speicherort der Konfigurationsdatei für den Bereitsteller und die Bibliothek sowie einige weitere Parameter.

Wählen Sie beispielsweise wie zuvor beschrieben Europa, Westen als Bereitstellungsstandort mit dem vierstelligen Namen SECE aus. Die Beispielkonfigurationsdatei des Deployers LAB-SECE-DEP05-INFRASTRUCTURE.tfvars befindet sich im Ordner ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/LAB-SECE-DEP05-INFRASTRUCTURE.

Die Beispielkonfigurationsdatei der SAP-Bibliothek LAB-SECE-SAP_LIBRARY.tfvars befindet sich im Ordner ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/LAB-SECE-SAP_LIBRARY.

Legen Sie die Umgebungsvariablen für den Dienstprinzipal fest:
```
export ARM_SUBSCRIPTION_ID="<subscriptionId>"
export       ARM_CLIENT_ID="<appId>"
export   ARM_CLIENT_SECRET="<password>"
export       ARM_TENANT_ID="<tenantId>"
```
Wenn Sie das Skript von einer Arbeitsstation ausführen, die nicht Teil des Bereitstellungsnetzwerks ist, oder wenn Sie es aus Cloud Shell ausführen, können Sie den folgenden Befehl verwenden, um die Umgebungsvariable festzulegen, welche die Konnektivität von Ihrer IP-Adresse zulässt:
```
export TF_VAR_Agent_IP=<your-public-ip-address>
```
Wenn Sie die Konfigurationswebanwendung bereitstellen, müssen Sie die folgenden Umgebungsvariablen ebenfalls festlegen:
```
export TF_VAR_app_registration_app_id=<appRegistrationId>
export    TF_VAR_webapp_client_secret=<appRegistrationPassword>
export                  TF_use_webapp=true
```

Erstellen Sie den Deployer und die SAP-Bibliothek, und fügen Sie mithilfe dieses Skripts die Dienstprinzipaldetails zum Bereitstellungsschlüsseltresor hinzu:


export            env_code="LAB"
export           vnet_code="DEP05"
export         region_code="SECE"

export     DEPLOYMENT_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"
export         CONFIG_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES"
export SAP_AUTOMATION_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"

cd $CONFIG_REPO_PATH

az login --service-principal -u "${ARM_CLIENT_ID}" -p="${ARM_CLIENT_SECRET}" --tenant "${ARM_TENANT_ID}"

deployer_parameter_file="${CONFIG_REPO_PATH}/DEPLOYER/${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE/${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE.tfvars"
library_parameter_file="${CONFIG_REPO_PATH}/LIBRARY/${env_code}-${region_code}-SAP_LIBRARY/${env_code}-${region_code}-SAP_LIBRARY.tfvars"

${SAP_AUTOMATION_REPO_PATH}/deploy/scripts/deploy_controlplane.sh  \
    --deployer_parameter_file "${deployer_parameter_file}"         \
    --library_parameter_file "${library_parameter_file}"           \
    --subscription "${ARM_SUBSCRIPTION_ID}"                        \
    --spn_id "${ARM_CLIENT_ID}"                                    \
    --spn_secret "${ARM_CLIENT_SECRET}"                            \
    --tenant_id "${ARM_TENANT_ID}"

Führen Sie bei Authentifizierungsproblemen den Befehl az logout aus, um sich abzumelden und den Zwischenspeicher token-cache zu löschen. Führen Sie den Befehl az login aus, um sich erneut zu authentifizieren.

Warten Sie, bis das Automatisierungsframework die Terraform-Vorgänge plan und apply ausgeführt hat.

Die Bereitstellung des Bereitstellers kann etwa 15 bis 20 Minuten dauern.

Sie müssen sich für die nächsten Schritte einige Werte notieren. Suchen Sie in der Ausgabe nach diesem Textblock:

#########################################################################################
#                                                                                       #
#  Please save these values:                                                            #
#     - Key Vault: LABSECEDEP05user39B                                                  #
#     - Deployer IP: x.x.x.x                                                            #
#     - Storage Account: labsecetfstate53e                                              #
#     - Web Application Name: lab-sece-sapdeployment39B                                 #
#     - App registration Id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx                       #
#                                                                                       #
#########################################################################################

Öffnen Sie das Azure-Portal.

Klicken Sie auf Ressourcengruppen. Suchen Sie nach neuen Ressourcengruppen für die Infrastruktur und Bibliothek des Bereitstellers. Beispielsweise könnten die Werte LAB-[region]-DEP05-INFRASTRUCTURE und LAB-[region]-SAP_LIBRARY angezeigt werden.

Die Inhalte der Ressourcengruppe für den Deployer und die SAP-Bibliothek sind hier dargestellt.

Die Terraform-Zustandsdatei wird jetzt im Speicherkonto abgelegt, dessen Name tfstate enthält. Das Speicherkonto verfügt über einen Container namens tfstate mit den Zustandsdateien des Bereitstellers und der Bibliothek. Die folgende Darstellung zeigt den Inhalt des tfstate-Containers nach einer erfolgreichen Bereitstellung der Steuerungsebene.

Bekannte Probleme und Lösungen

Hier sind einige Tipps zur Problembehandlung:

Wenn bei der Erstellung des Bereitstellermoduls der folgende Fehler auftritt, stellen Sie sicher, dass Sie sich beim Ausführen des Skripts im WORKSPACES-Verzeichnis befinden:
```
Incorrect parameter file.
The file must contain the environment attribute!!
```
Der folgende Fehler ist vorübergehend. Erneutes Ausführen des gleichen Befehls,deploy_controlplane.sh.
```
Error: file provisioner error
..
timeout - last error: dial tcp
```
Wenn direkt nach dem Ausführen des Skripts deploy_controlplane.sh Authentifizierungsprobleme auftreten, führen Sie den folgenden Befehl aus:
```
az logout

az login
```

Verbinden mit der Bereitsteller-VM

Nachdem die Steuerungsebene bereitgestellt wurde, wird der Terraform-Zustand mithilfe des Remote-Back-Ends azurerm gespeichert. Alle Geheimnisse zum Herstellen einer Verbindung mit dem virtuellen Bereitstellungscomputer sind in einem Schlüsseltresor in der Bereitstellungsressourcengruppe verfügbar.

So stellen Sie eine Verbindung zur Bereitsteller-VM her:

Melden Sie sich beim Azure-Portal an.
Wählen Sie oder suchen Sie nach Schlüsseltresoren.
Suchen Sie auf der Seite Schlüsseltresor nach dem Schlüsseltresor des Deployers. Der Name beginnt mit LAB[REGION]DEP05user. Filtern Sie bei Bedarf nach der Ressourcengruppe oder dem Ort.
Wählen Sie im linken Fensterbereich im Abschnitt Einstellungen die Option Geheimnisse aus.
Wählen Sie das Geheimnis aus, das sshkey enthält. Ein Beispiel hierfür ist LAB-[REGION]-DEP05-sshkey.
Wählen Sie auf der Seite des Geheimnisses die aktuelle Version aus. Kopieren Sie dann den Geheimniswert.
Öffnen Sie einen normalen Text-Editor. Kopieren Sie den Geheimniswert.
Speichern Sie die Datei, in der Sie die SSH-Schlüssel abgelegt haben. Verwenden Sie z. B. C:\\Users\\<your-username>\\.ssh.
Speichern Sie die Datei . Wenn Sie zu Speichern als Typ aufgefordert werden, wählen Sie Alle Dateien, wenn SSH keine Option ist. Verwenden Sie z. B. deployer.ssh.
Stellen Sie über einen beliebigen SSH-Client wie Visual Studio Code die Verbindung zur Bereitsteller-VM her. Verwenden Sie die zuvor notierte öffentliche IP-Adresse und den heruntergeladenen SSH-Schlüssel. Anweisungen zum Herstellen einer Verbindung zum Bereitsteller mithilfe von Visual Studio Code finden Sie unter Herstellen einer Verbindung zum Bereitsteller mithilfe von Visual Studio Code. Konvertieren Sie zunächst die SSH-Schlüsseldatei mit PuTTYGen, wenn Sie PuTTY verwenden.

Hinweis

Der Standardbenutzername lautet azureadm.

Stellen Sie sicher, dass die zum Speichern des SSH-Schlüssels verwendete Datei die Datei mit dem richtigen Format speichern kann, d. h. ohne Wagenrücklaufzeichen (CR). Verwenden Sie Visual Studio Code oder Notepad++.

Sobald die Verbindung zur Bereitsteller-VM hergestellt wurde, können Sie die SAP-Software mithilfe der Stückliste (Bill Of Materials, BOM) herunterladen.

Herstellen einer Verbindung zur Bereitsteller-VM ohne öffentliche IP-Adresse

Für Bereitstellungen ohne Konnektivität über eine öffentliche IP-Adressen ist die direkte Konnektivität über das Internet nicht zulässig. In diesen Fällen können Sie eine Azure Bastion-Jumpbox verwenden, oder Sie können den nächsten Schritt von einem Computer ausführen, der über die Konnektivität zum virtuellen Azure-Netzwerk verfügt.

Im folgenden Beispiel wird Azure Bastion verwendet.

So stellen Sie eine Verbindung zum Bereitsteller her:

Melden Sie sich beim Azure-Portal an.
Navigieren Sie zu der Ressourcengruppe, welche die Deployer VM enthält.
Stellen Sie mithilfe von Azure Bastion eine Verbindung mit der VM her.
Der Standardbenutzername lautet azureadm.
Wählen Sie Privater SSH-Schlüssel aus Azure Key Vault aus.
Wählen Sie das Abonnement aus, das die Steuerungsebene enthält.
Wählen Sie den Schlüsseltresor des Bereitstellers aus.
Wählen Sie in der Liste der Geheimnisse das Geheimnis aus, das auf -sshkey endet.
Stellen Sie eine Verbindung mit der VM her.

Die restlichen Aufgaben müssen auf dem Bereitsteller ausgeführt werden.

Sichern Sie die Steuerungsebene

Die Steuerungsebene ist der wichtigste Teil des SAP-Automatisierungsframeworks. Es ist wichtig, die Steuerebene zu sichern. Die folgenden Schritte helfen Ihnen dabei, die Steuerungsebene zu sichern.

Sie sollten die tfvars-Datei der Steuerebene aktualisieren, um private Endpunkte zu aktivieren und den öffentlichen Zugriff auf die Speicherkonten und Schlüsseltresor zu blockieren.

Sie können das sync_deployer.sh-Skript verwenden, um die Konfigurationsdateien für die Steuerungsebene in die Bereitsteller-VM zu kopieren. Melden Sie sich bei der Deployer VM an und aktualisieren Sie den folgenden Befehl, um den Namen Ihres Speicherkontos für den Terraform-Zustand zu verwenden. Führen Sie anschließend das folgende Skript aus:
```
terraform_state_storage_account=labsecetfstate###

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES

../sap-automation/deploy/scripts/sync_deployer.sh --storageaccountname $terraform_state_storage_account --state_subscription $ARM_SUBSCRIPTION_ID
```
Mit diesem Befehl werden die tfvars-Konfigurationsdateien aus dem Speicherkonto der SAP-Bibliothek in die Deployer VM kopiert.

Ändern Sie die Konfigurationsdateien für die Steuerungsebene folgendermaßen:


    # use_private_endpoint defines that the storage accounts and key vaults have private endpoints enabled
    use_private_endpoint = true

    # enable_firewall_for_keyvaults_and_storage defines that the storage accounts and key vaults have firewall enabled
    enable_firewall_for_keyvaults_and_storage = true

    # public_network_access_enabled controls if storage account and key vaults have public network access enabled
    public_network_access_enabled = false

    #if you want to use the webapp
    use_webapp=true

Führen Sie die Bereitstellung erneut aus, um die Änderungen anzuwenden. Aktualisieren Sie den Namen des Speicherkontos und Schlüsseltresors im Skript.


export ARM_SUBSCRIPTION_ID="<subscriptionId>"
export       ARM_CLIENT_ID="<appId>"
export   ARM_CLIENT_SECRET="<password>"
export       ARM_TENANT_ID="<tenantId>"

Erstellen Sie den Deployer und die SAP-Bibliothek.


export            env_code="LAB"
export           vnet_code="DEP05"
export         region_code="SECE"

terraform_state_storage_account=labsecetfstate###
                     vault_name="LABSECEDEP05user###"

export     DEPLOYMENT_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"
export         CONFIG_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES"
export SAP_AUTOMATION_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"

cd $CONFIG_REPO_PATH

deployer_parameter_file="${CONFIG_REPO_PATH}/DEPLOYER/${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE/${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE.tfvars"
 library_parameter_file="${CONFIG_REPO_PATH}/LIBRARY/${env_code}-${region_code}-SAP_LIBRARY/${env_code}-${region_code}-SAP_LIBRARY.tfvars"

az logout 
az login --service-principal -u "${ARM_CLIENT_ID}" -p="${ARM_CLIENT_SECRET}" --tenant "${ARM_TENANT_ID}"

${SAP_AUTOMATION_REPO_PATH}/deploy/scripts/deploy_controlplane.sh  \
    --deployer_parameter_file "${deployer_parameter_file}"         \
    --library_parameter_file "${library_parameter_file}"           \
    --subscription "${ARM_SUBSCRIPTION_ID}"                        \
    --storageaccountname "${terraform_state_storage_account}"      \
    --vault "${vault_name}"

Bereitstellen der Webanwendung

Sie können die Webanwendung mithilfe des folgenden Skripts bereitstellen:

export            env_code="LAB"
export           vnet_code="DEP05"
export         region_code="SECE"
export         webapp_name="<webAppName>"
export              app_id="<appRegistrationId>"
export           webapp_id="<webAppId>"

export DEPLOYMENT_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"

cd $DEPLOYMENT_REPO_PATH
cd Webapp/SDAF

dotnet build SDAFWebApp.csproj
dotnet publish SDAFWebApp.csproj --output publish
cd publish

zip -r SDAF.zip .

az webapp deploy --resource-group ${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE --name $webapp_name --src-path SDAF.zip --type zip

az ad app update --id $app_id --web-home-page-url https://$webapp_name.azurewebsites.net --web-redirect-uris https://$webapp_name.azurewebsites.net/ https://$webapp_name.azurewebsites.net/.auth/login/aad/callback
az role assignment create --assignee $webapp_id --role reader --subscription $ARM_SUBSCRIPTION_ID --scope /subscriptions/$ARM_SUBSCRIPTION_ID
az webapp restart --resource-group ${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE --name $webapp_name

Sammeln von Informationen zu Workloadzonen

Sammeln Sie die folgenden Informationen in einem Text-Editor. Die folgenden Informationen wurden am Ende der Phase „Bereitstellen der Steuerungsebene“ gesammelt.
1. Der Name des Speicherkontos der Terraform-Zustandsdatei in der Bibliotheksressourcengruppe setzt sich folgendermaßen zusammen:
  - Nach dem vorherigen Beispiel lautet die Ressourcengruppe LAB-SECE-SAP_LIBRARY.
  - Der Name des Speicherkontos enthält labsecetfstate.
2. Der Name des Schlüsseltresors in der Bereitstellerressourcengruppe setzt sich folgendermaßen zusammen:
  - Nach dem vorherigen Beispiel lautet die Ressourcengruppe LAB-SECE-DEP05-INFRASTRUCTURE.
  - Der Name des Schlüsseltresors enthält LABSECEDEP05user.
3. Die öffentliche IP-Adresse der Bereitsteller-VM. Wechseln Sie zur Ressourcengruppe Ihres Bereitstellers, öffnen Sie den virtuellen Bereitstellungscomputer, und kopieren Sie die öffentliche IP-Adresse.
Sie müssen die folgenden Informationen sammeln:
1. Der Name der Zustandsdatei des Bereitstellers befindet sich in der Bibliotheksressourcengruppe:
  - Wählen Sie Bibliotheksressourcengruppe>Zustandsspeicherkonto>Container>tfstate aus. Kopieren Sie den Namen der Zustandsdatei des Bereitstellers.
  - Nach dem vorherigen Beispiel lautet der Name des Blobs LAB-SECE-DEP05-INFRASTRUCTURE.terraform.tfstate.

Registrieren Sie bei Bedarf den Dienstprinzipal. Für dieses Tutorial ist dieser Schritt nicht erforderlich.

Wenn eine Umgebung zum ersten Mal instanziiert wird, muss ein Dienstprinzipal registriert werden. In diesem Tutorial befindet sich die Steuerungsebene in der LAB-Umgebung, und die Workloadzone befindet sich ebenfalls in LAB. Daher muss ein Dienstprinzipal für die LAB-Umgebung registriert werden.

export ARM_SUBSCRIPTION_ID="<subscriptionId>"
export       ARM_CLIENT_ID="<appID>"
export   ARM_CLIENT_SECRET="<password>"
export       ARM_TENANT_ID="<tenant>"
export           key_vault="<vaultName>"
export            env_code="LAB"
export         region_code="SECE"

export SAP_AUTOMATION_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"
export         CONFIG_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES"


${SAP_AUTOMATION_REPO_PATH}/deploy/scripts/set_secrets.sh \
    --environment "${env_code}"                           \
    --region "${region_code}"                             \
    --vault "${key_vault}"                                \
    --subscription "${ARM_SUBSCRIPTION_ID}"               \
    --spn_id "${ARM_CLIENT_ID}"                           \
    --spn_secret "${ARM_CLIENT_SECRET}"                   \
    --tenant_id "${ARM_TENANT_ID}"

Vorbereiten der Bereitstellung der Workloadzone

Verbinden Sie für die folgenden Schritte zu Ihrem virtuellen Bereitstellungscomputer. Eine Kopie des Repositorys ist jetzt vorhanden.

Bereitstellen der Workloadzone

Verwenden Sie das install_workloadzone-Skript, um die SAP-Workloadzone bereitzustellen.

Navigieren Sie auf der Bereitsteller-VM zum Ordner Azure_SAP_Automated_Deployment.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LANDSCAPE/LAB-SECE-SAP04-INFRASTRUCTURE

Öffnen Sie optional die Konfigurationsdatei der Workloadzone, und ändern Sie bei Bedarf den logischen Netzwerknamen entsprechend dem Netzwerknamen.
Starten Sie die Bereitstellung der Workloadzone. Die zuvor gesammelten Details sind hier erforderlich:
- Name der tfstate-Datei des Bereitstellers (im Container tfstate)
- Name des tfstate-Speicherkontos
- Name des Deployer-Schlüsseltresors


export     ARM_SUBSCRIPTION_ID="<subscriptionId>"
export           ARM_CLIENT_ID="<appId>"
export       ARM_CLIENT_SECRET="<password>"
export           ARM_TENANT_ID="<tenantId>"

export       deployer_env_code="LAB"
export            sap_env_code="LAB"
export             region_code="SECE"

export      deployer_vnet_code="DEP05"
export               vnet_code="SAP04"

export tfstate_storage_account="<storageaccountName>"
export               key_vault="<vaultName>"

export CONFIG_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES"
export SAP_AUTOMATION_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"

az login --service-principal -u "${ARM_CLIENT_ID}" -p="${ARM_CLIENT_SECRET}" --tenant "${ARM_TENANT_ID}"

cd "${CONFIG_REPO_PATH}/LANDSCAPE/${sap_env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE"

parameterFile="${sap_env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE.tfvars"
deployerState="${deployer_env_code}-${region_code}-${deployer_vnet_code}-INFRASTRUCTURE.terraform.tfstate"

$SAP_AUTOMATION_REPO_PATH/deploy/scripts/install_workloadzone.sh  \
    --parameterfile "${parameterFile}"                            \
    --deployer_environment "${deployer_env_code}"                 \
    --deployer_tfstate_key  "${deployerState}"                    \
    --keyvault "${key_vault}"                                     \
    --storageaccountname "${tfstate_storage_account}"             \
    --subscription "${ARM_SUBSCRIPTION_ID}"                       \
    --spn_id "${ARM_CLIENT_ID}"                                   \
    --spn_secret "${ARM_CLIENT_SECRET}"                           \
    --tenant_id "${ARM_TENANT_ID}"

Die Bereitstellung der Workloadzone sollte automatisch gestartet werden.

Warten Sie, bis die Bereitstellung abgeschlossen ist. Die neue Ressourcengruppe wird im Azure-Portal angezeigt.

Vorbereiten der Bereitstellung der SAP-Systeminfrastruktur

Verbinden Sie für die folgenden Schritte zu Ihrem virtuellen Bereitstellungscomputer. Eine Kopie des Repositorys ist jetzt vorhanden.

Wechseln Sie in den Ordner WORKSPACES/SYSTEM, und kopieren Sie die Beispielkonfigurationsdateien, die Sie verwenden möchten, aus dem Repository.

Bereitstellen der SAP-Systeminfrastruktur

Sobald die Konfiguration der Workloadzone abgeschlossen ist, können Sie die Ressourcen der SAP-Systeminfrastruktur bereitstellen. Das SAP-System erstellt Ihre VMs und unterstützenden Komponenten für Ihre SAP-Anwendung. Verwenden Sie das Skript installer.sh, um das SAP-System zu installieren.

Das SAP-System stellt Folgendes bereit:

Die Datenbankebene, auf der Datenbank-VMs und deren Datenträger sowie eine Azure Standard Load Balancer-Instanz bereitgestellt werden. Sie können HANA-Datenbanken oder AnyDB-Datenbanken in dieser Schicht betreiben.
Den SCS-Tarif, der eine kundendefinierte Anzahl von VMs und eine Azure Load Balancer Standard-Instanz bereitstellt.
Die Anwendungsebene, auf der die virtuellen Computer und ihre Datenträger bereitgestellt werden.
Die Web Dispatcher-Ebene.

Bereitstellen des SAP-Systems.


export             sap_env_code="LAB"
export              region_code="SECE"
export                vnet_code="SAP04"
export                      SID="L00"

export         CONFIG_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES"
export SAP_AUTOMATION_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"

cd ${CONFIG_REPO_PATH}/SYSTEM/${sap_env_code}-${region_code}-${vnet_code}-${SID}

${DEPLOYMENT_REPO_PATH}/deploy/scripts/installer.sh                             \
    --parameterfile "${sap_env_code}-${region_code}-${vnet_code}-${SID}.tfvars" \
    --type sap_system

Überprüfen Sie, ob sich die Systemressourcengruppe jetzt im Azure-Portal befindet.

Abrufen von SAP-Software mithilfe der Stückliste

Das Automatisierungsframework bietet Ihnen Tools zum Herunterladen von Software aus SAP mithilfe der SAP-Stückliste (Bill Of Materials, BOM). Die Software wird in die SAP-Bibliothek heruntergeladen, die als Archiv für alle zum Bereitstellen von SAP erforderlichen Medien fungiert.

Die SAP-BOM-Datei imitiert den SAP-Wartungsplaner. Es gibt relevante Produktbezeichner und eine Reihe von Download-URLs.

Ein Beispielauszug einer BOM-Datei sieht folgendermaßen aus:


---
name:    'S41909SPS03_v0010'
target:  'S/4 HANA 1909 SPS 03'
version: 7

product_ids:
  dbl:       NW_ABAP_DB:S4HANA1909.CORE.HDB.ABAP
  scs:       NW_ABAP_ASCS:S4HANA1909.CORE.HDB.ABAP
  scs_ha:    NW_ABAP_ASCS:S4HANA1909.CORE.HDB.ABAPHA
  pas:       NW_ABAP_CI:S4HANA1909.CORE.HDB.ABAP
  pas_ha:    NW_ABAP_CI:S4HANA1909.CORE.HDB.ABAPHA
  app:       NW_DI:S4HANA1909.CORE.HDB.PD
  app_ha:    NW_DI:S4HANA1909.CORE.HDB.ABAPHA
  web:       NW_Webdispatcher:NW750.IND.PD
  ers:       NW_ERS:S4HANA1909.CORE.HDB.ABAP
  ers_ha:    NW_ERS:S4HANA1909.CORE.HDB.ABAPHA

materials:
  dependencies:
    - name:     HANA_2_00_055_v0005ms

  media:
    # SAPCAR 7.22
    - name:         SAPCAR
      archive:      SAPCAR_1010-70006178.EXE
      checksum:     dff45f8df953ef09dc560ea2689e53d46a14788d5d184834bb56544d342d7b
      filename:     SAPCAR
      permissions:  '0755'
      url:          https://softwaredownloads.sap.com/file/0020000002208852020

    # Kernel
    - name:         "Kernel Part I ; OS: Linux on x86_64 64bit ; DB: Database independent"

Für diese Beispielkonfiguration ist die Ressourcengruppe LAB-SECE-DEP05-INFRASTRUCTURE. Der Name des Schlüsseltresors des Bereitstellers enthält LABSECEDEP05user. Sie verwenden diese Informationen, um die Geheimnisse des Schlüsseltresors Ihres Deployers zu konfigurieren.

Verbinden Sie für die folgenden Schritte zu Ihrem virtuellen Bereitstellungscomputer. Eine Kopie des Repositorys ist jetzt vorhanden.
Fügen Sie ein Geheimnis mit dem Benutzernamen für Ihr SAP-Benutzerkonto hinzu. Ersetzen Sie <vaultName> durch den Namen Ihres Schlüssels im Azure-Schlüsseltresor. Ersetzen Sie außerdem <sap-username> durch Ihren SAP-Benutzernamen.
```
export key_vault=<vaultName>
    sap_username=<sap-username>

az keyvault secret set --name "S-Username" --vault-name $key_vault --value "${sap_username}";
```
Fügen Sie ein Geheimnis mit dem Passwort für Ihr SAP-Benutzerkonto hinzu. Ersetzen Sie <vaultName> durch den Namen des Schlüsseltresors Ihres Bereitstellers und <sap-password> durch Ihr SAP-Kennwort.

Hinweis

Die Verwendung von einfachen Anführungszeichen beim Festlegen von sap_user_password ist wichtig. Die Verwendung von Sonderzeichen im Kennwort kann andernfalls zu unvorhersehbaren Ergebnissen führen.
```
sap_user_password='<sap-password>'

az keyvault secret set --name "S-Password" --vault-name "${key_vault}" --value="${sap_user_password}";
```
Konfigurieren Sie Ihre SAP-Parameterdatei für den Downloadprozess. Laden Sie dann die SAP-Software mithilfe von Ansible-Playbooks herunter. Führen Sie die folgenden Befehle aus:
```
cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
mkdir BOMS
cd BOMS

vi sap-parameters.yaml
```
Aktualisieren Sie die bom_base_name mit dem Namen BOM. Ersetzen Sie <Deployer KeyVault Name> durch den Namen des Azure Key Vault für die Bereitstellungsressourcengruppe.

Ihre JSON-Datei sollte dem folgenden Beispiel ähneln:
```
bom_base_name:                 S42022SPS00_v0001ms
deployer_kv_name:              <vaultName>
BOM_directory:                 ${HOME}/Azure_SAP_Automated_Deployment/samples/SAP
```
Führen Sie das Ansible-Playbook aus, um die Software herunterzuladen. Playbooks können beispielsweise über das Menü des Downloadprogramms ausgeführt werden. Führen Sie das Skript download_menu aus.
```
${HOME}/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/download_menu.sh
```

Wählen Sie aus, welche Playbooks ausgeführt werden sollen.

1) BoM Downloader
3) Quit
Please select playbook:

Wählen Sie das Playbook 1) BoM Downloader aus, um die in der BOM-Datei beschriebene SAP-Software in das Speicherkonto herunterzuladen. Überprüfen Sie, ob der sapbits Container über alle Medien für die Installation verfügt.

Sie können das Playbook über das Konfigurationsmenü oder direkt über die Befehlszeile ausführen.


cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/SYSTEM/BOMS/

export           ANSIBLE_PRIVATE_KEY_FILE=sshkey

playbook_options=(
        --inventory-file="${sap_sid}_hosts.yaml"
        --private-key=${ANSIBLE_PRIVATE_KEY_FILE}
        --extra-vars="_workspace_directory=`pwd`"
        --extra-vars="@sap-parameters.yaml"
        --extra-vars="bom_processing=true"
        "${@}"
)

# Run the playbook to retrieve the ssh key from the Azure key vault
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/pb_get-sshkey.yaml

# Run the playbook to perform the Operating System configuration
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_bom_downloader.yaml

Bei Bedarf können Sie den SAP-Benutzeranmeldeinformationen auch als Parameter übergeben.


cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/SYSTEM/BOMS/

sap_username=<sap-username>
sap_user_password='<sap-password>'

export           ANSIBLE_PRIVATE_KEY_FILE=sshkey

playbook_options=(
        --inventory-file="${sap_sid}_hosts.yaml"
        --private-key=${ANSIBLE_PRIVATE_KEY_FILE}
        --extra-vars="_workspace_directory=`pwd`"
        --extra-vars="@sap-parameters.yaml"
        --extra-vars="s_user=${sap_username}"
        --extra-vars="s_password=${sap_user_password}"
        --extra-vars="bom_processing=true"
        "${@}"
)

# Run the playbook to retrieve the ssh key from the Azure key vault
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/pb_get-sshkey.yaml

# Run the playbook to perform the Operating System configuration
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_bom_downloader.yaml

SAP-Anwendungsinstallation

Die Installation der SAP-Anwendung erfolgt über Ansible-Playbooks.

Wechseln Sie zum Systembereitstellungsordner.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/SYSTEM/LAB-SECE-SAP04-L00/

Stellen Sie sicher, dass sich die folgenden Dateien im aktuellen Ordner befinden: sap-parameters.yaml und L00_host.yaml.

Für ein eigenständiges SAP S/4HANA-System müssen acht Playbooks nacheinander ausgeführt werden. Playbooks können beispielsweise über das Menü der Konfiguration ausgeführt werden.

Führen Sie das Skript configuration_menu aus.

${HOME}/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/configuration_menu.sh

Wählen Sie die auszuführenden Playbooks aus.

Playbook: Basiskonfiguration des Betriebssystems

Mit diesem Playbook wird die allgemeine Konfiguration des Betriebssystems auf allen Computern eingerichtet. Diese umfasst die Konfiguration von Softwarerepositorys, Paketen und Diensten.