Déployer SAP Deployment Automation Framework pour l’échelle de l’entreprise

Cet article explique comment effectuer des déploiements à l’aide de SAP Deployment Automation Framework. Cet exemple utilise Azure Cloud Shell pour déployer l’infrastructure du plan de contrôle. La machine virtuelle du déployeur crée l’infrastructure restante et SAP HANA configurations.

Il existe trois étapes principales d’un déploiement SAP sur Azure avec l’infrastructure d’automatisation :

Préparez la région. Vous déployez des composants pour prendre en charge l’infrastructure d’automatisation SAP dans une région Azure spécifiée. Dans cette étape, vous :
1. Créez l’environnement de déploiement.
2. Créez un stockage partagé pour les fichiers d’état Terraform.
3. Créez un espace de stockage partagé pour le support d’installation SAP.
Préparez la zone de charge de travail. Vous déployez les composants de la zone de charge de travail, tels que le réseau virtuel et les coffres de clés.
Déployez le système. Vous déployez l’infrastructure pour le système SAP.

Il existe plusieurs flux de travail dans le processus d’automatisation du déploiement. Cet article se concentre sur un flux de travail pour faciliter le déploiement. Vous pouvez déployer ce flux de travail, l’environnement autonome SAP S4 HANA à l’aide de Bash. Les sections suivantes décrivent la hiérarchie générale et différentes phases du déploiement.

Prerequisites

Un abonnement Azure. Si vous n’en avez pas, créez un compte gratuit.
Azure CLI version 2.5.0 ou ultérieure.
Terraform version 1.5 ou ultérieure.
Git pour cloner les dépôts du cadre d'automatisation.
Un client SSH ou Azure Bastion pour la connexion à la machine virtuelle du déployeur.
Un compte Azure disposant d’autorisations pour créer des principaux de service et attribuer des rôles (Contributeur et Administrateur de l’accès utilisateur) sur l’abonnement cible.
Quota suffisant de cœurs d'abonnement Azure pour les SKU des familles DdSV4 et EdsV4 dans la région sélectionnée. Environ 50 cœurs disponibles pour chaque famille de machines virtuelles doivent suffire.
Un compte d’utilisateur SAP valide (SAP-User ou compte S-User) avec des privilèges de téléchargement de logiciels pour télécharger le logiciel SAP.
Référentiel SAP Deployment Automation Framework sur GitHub.
(Facultatif) .NET SDK si vous envisagez de déployer l’application web de configuration.

Vue d’ensemble de l’environnement

SAP Deployment Automation Framework a deux composants principaux :

Infrastructure de déploiement (plan de contrôle)
Infrastructure SAP (charge de travail SAP)

Le diagramme suivant montre la dépendance entre le plan de contrôle et le plan d’application.

Diagramme montrant la conception de l’infrastructure.

Le cadre utilise Terraform pour le déploiement de l'infrastructure et Ansible pour la configuration du système d'exploitation et des applications. Le diagramme suivant montre la séparation logique du plan de contrôle et de la zone de charge de travail.

Diagramme montrant l’environnement SAP Deployment Automation Framework.

Zone de gestion

La zone de gestion contient l’infrastructure du plan de contrôle à partir de laquelle d’autres environnements sont déployés. Une fois la zone de gestion déployée, vous devez rarement, le cas échéant, redéployer.

Diagramme montrant le plan de contrôle.

Le déployeur est le moteur d’exécution de l’infrastructure d’automatisation SAP. Cette machine virtuelle préconfigurée est utilisée pour exécuter des commandes Terraform et Ansible.

La bibliothèque SAP fournit le stockage persistant pour les fichiers d’état Terraform et le support d’installation SAP téléchargé pour le plan de contrôle.

Vous configurez le déployeur et la bibliothèque dans un fichier de variable Terraform .tfvars . Pour plus d’informations, consultez Configurer le plan de contrôle.

Zone de charge de travail

Une application SAP a généralement plusieurs niveaux de déploiement. Par exemple, vous pouvez avoir des niveaux de développement, d’assurance qualité et de production. SAP Deployment Automation Framework appelle ces niveaux des zones de charge de travail.

Diagramme montrant la zone de charge de travail.

La zone de charge de travail SAP contient les composants réseau et partagés des machines virtuelles SAP. Ces composants incluent des tables de routage, des groupes de sécurité réseau et des réseaux virtuels. Le paysage offre la possibilité de diviser les déploiements en différents environnements. Pour plus d’informations, consultez Configurer la zone de charge de travail.

Le déploiement du système se compose des machines virtuelles pour exécuter l’application SAP, notamment les niveaux web, application et base de données. Pour plus d’informations, consultez Configurer le système SAP.

Mettez en place le Cloud Shell

Accédez à Azure Cloud Shell.
Connectez-vous à votre compte Azure.
```
az login
```
Authentifiez votre connexion. Ne fermez pas la fenêtre tant que vous n’êtes pas invité.

Validez votre abonnement actif et enregistrez votre ID d’abonnement :

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

az account list --output=table | grep True

Si nécessaire, modifiez votre abonnement actif.

az account set --subscription <Subscription ID>

Vérifiez que votre abonnement actif a changé.

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

Si vous le souhaitez, supprimez tous les artefacts de déploiement. Utilisez cette commande lorsque vous souhaitez supprimer tous les restes des artefacts de déploiement précédents.
```
cd ~
rm -rf Azure_SAP_Automated_Deployment .sap_deployment_automation .terraform.d
```

Créez le dossier de déploiement et clonez le référentiel.

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

Si vous le souhaitez, validez les versions de Terraform et les Azure CLI disponibles sur votre instance de Cloud Shell.
```
./sap-automation/deploy/scripts/helpers/check_workstation.sh
```
Pour exécuter l’infrastructure Automation, effectuez une mise à jour vers les versions suivantes :
- az version 2.5.0 ou ultérieure.
- terraform version 1.5 ou ultérieure. Effectuez une mise à niveau à l’aide des instructions Terraform, si nécessaire.

Créer un service principal

L’infrastructure de déploiement SAP Automation utilise des principaux de service pour le déploiement. Créez un 'service principal' pour le déploiement de votre plan de contrôle. Pour créer des principaux de service, veillez à utiliser un compte avec les autorisations appropriées.

Lorsque vous choisissez un nom pour votre principal de service, assurez-vous que le nom est unique dans votre locataire Azure.

Accordez au principal de service les autorisations Contributeur et Administrateur de l'accès utilisateur.

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"

Passez en revue le résultat. Par exemple:

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

Copiez les détails de sortie. Assurez-vous d’enregistrer les valeurs pour appId, password et Tenant.

La sortie correspond aux paramètres suivants. Vous utilisez ces paramètres dans les étapes ultérieures, avec des commandes d’automatisation.

Nom d’entrée du paramètre Nom de sortie

spn_id appId

spn_secret password

tenant_id tenant

Nom d’entrée du paramètre	Nom de sortie
`spn_id`	`appId`
`spn_secret`	`password`
`tenant_id`	`tenant`

(Facultatif) Attribuez le rôle Administrateur de l’accès utilisateur à votre principal de service.

export appId="<appId>"

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

Important

Si vous n’attribuez pas le rôle Administrateur d’accès utilisateur au principal du service, vous ne pouvez pas attribuer d’autorisations à l’aide de l’automatisation.

Configurer les informations d’identification de l’application web du plan de contrôle

Dans le cadre du plan de contrôle de l’infrastructure SAP Automation, vous pouvez éventuellement créer une application web interactive qui vous aide à créer les fichiers de configuration requis.

Capture d’écran montrant la page d’accueil de l’application web.

Créer un enregistrement d'application

Si vous souhaitez utiliser l’application web, vous devez d’abord créer une inscription d’application à des fins d’authentification. Ouvrez Cloud Shell et exécutez les commandes suivantes :

Remplacez, si nécessaire, LAB par votre environnement.

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

Note

Vérifiez que vous êtes connecté à l’aide d’un compte d’utilisateur disposant des autorisations requises pour créer des inscriptions d’applications. Pour plus d’informations sur les inscriptions d’applications, consultez Créer une inscription d’application.

Copiez les détails de sortie. Veillez à enregistrer les valeurs pour App registration ID et App registration password.

La sortie correspond aux paramètres suivants. Vous utilisez ces paramètres dans les étapes ultérieures, avec des commandes d’automatisation.

Nom d’entrée du paramètre	Nom de sortie
`app_registration_app_id`	`App registration ID`
`webapp_client_secret`	`App registration password`

Afficher les fichiers de configuration

Ouvrez Visual Studio Code à partir de Cloud Shell.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
code .

Développez le WORKSPACES répertoire. Il existe six sous-dossiers : CONFIGURATION, DEPLOYER, LANDSCAPE, LIBRARY, SYSTEM et BOMS. Développez chacun de ces dossiers pour trouver des fichiers de configuration de déploiement régional.

Recherchez les fichiers de variables Terraform dans le sous-dossier approprié. Par exemple, le DEPLOYER fichier de variable Terraform peut ressembler à cet exemple :

# 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

Notez les emplacements des fichiers de variables Terraform pour les modifications ultérieures pendant le déploiement.

Recherchez les fichiers de variables Terraform pour la bibliothèque SAP dans le sous-dossier approprié. Par exemple, le LIBRARY fichier de variable Terraform peut ressembler à cet exemple :

# 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

Notez les emplacements des fichiers de variables Terraform pour les modifications ultérieures pendant le déploiement.

Important

Vérifiez que le dns_label correspond à votre instance de Azure DNS privé.

Déployer le plan de contrôle

Utilisez le script deploy_controlplane.sh pour déployer l’éditeur de déploiement et la bibliothèque. Ces éléments de déploiement constituent le plan de contrôle d’une zone d’automatisation choisie.

Le déploiement passe par des cycles de déploiement de l’infrastructure, l’actualisation de l’état et le chargement des fichiers d’état Terraform dans le compte de stockage de bibliothèque. Toutes ces étapes sont empaquetées dans un seul script de déploiement. Le script a besoin de l’emplacement du fichier de configuration pour l’outil de déploiement et la bibliothèque, ainsi que d’autres paramètres.

Par exemple, choisissez Europe Ouest comme emplacement de déploiement, avec le nom SECEà quatre caractères, comme décrit précédemment. L’exemple de fichier LAB-SECE-DEP05-INFRASTRUCTURE.tfvars de configuration de l’outil de déploiement se trouve dans le ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/LAB-SECE-DEP05-INFRASTRUCTURE dossier.

L’exemple de fichier de LAB-SECE-SAP_LIBRARY.tfvars configuration de la bibliothèque SAP se trouve dans le ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/LAB-SECE-SAP_LIBRARY dossier.

Définissez les variables d’environnement pour le principal de service :
```
export ARM_SUBSCRIPTION_ID="<subscriptionId>"
export       ARM_CLIENT_ID="<appId>"
export   ARM_CLIENT_SECRET="<password>"
export       ARM_TENANT_ID="<tenantId>"
```
Si vous exécutez le script à partir d'une station de travail qui ne fait pas partie du réseau de déploiement ou de Cloud Shell, vous pouvez utiliser la commande suivante pour définir la variable d'environnement pour autoriser la connectivité à partir de votre adresse IP :
```
export TF_VAR_Agent_IP=<your-public-ip-address>
```
Si vous déployez l’application web de configuration, vous devez également définir les variables d’environnement suivantes :
```
export TF_VAR_app_registration_app_id=<appRegistrationId>
export    TF_VAR_webapp_client_secret=<appRegistrationPassword>
export                  TF_use_webapp=true
```

Créez l'outil de déploiement et la bibliothèque SAP et ajoutez les détails du principal de service au coffre de clés de déploiement à l’aide de ce script :

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

Si vous rencontrez des problèmes d’authentification, exécutez az logout pour vous déconnecter et effacer le token-cache. Exécutez az login ensuite pour réauthentifier.

Attendez que le framework d’automatisation exécute les opérations Terraform plan et apply.

Le déploiement du déployeur peut s’exécuter pendant environ 15 à 20 minutes.

Vous devez noter certaines valeurs pour les étapes à venir. Recherchez ce bloc de texte dans la sortie :

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

Accédez au portail Azure.

Sélectionnez Groupes de ressources. Recherchez de nouveaux groupes de ressources pour l’infrastructure et la bibliothèque du deployer. Par exemple, vous pouvez voir LAB-[region]-DEP05-INFRASTRUCTURE et LAB-[region]-SAP_LIBRARY.

Le contenu du groupe de ressources du déployeur et de la bibliothèque SAP s’affiche ici.

Le fichier d’état Terraform est maintenant placé dans le compte de stockage dont le nom contient tfstate. Le compte de stockage a un conteneur nommé tfstate avec les fichiers d’état du déployeur et de la bibliothèque. Le contenu du tfstate conteneur après un déploiement de plan de contrôle réussi s’affiche ici.

Problèmes courants et solutions

Voici quelques conseils de dépannage :

Si vous obtenez l’erreur suivante pour la création du module de déploiement, vérifiez que vous êtes dans le WORKSPACES répertoire lorsque vous exécutez le script :
```
Incorrect parameter file.
The file must contain the environment attribute!!
```
L’erreur suivante est temporaire. Réexécutez la même commande. deploy_controlplane.sh
```
Error: file provisioner error
..
timeout - last error: dial tcp
```
Si vous rencontrez des problèmes d’authentification directement après avoir exécuté le script deploy_controlplane.sh, exécutez cette commande :
```
az logout

az login
```

Se connecter à la machine virtuelle du déployeur

Une fois le plan de contrôle déployé, l’état Terraform est stocké à l’aide du back-end distant azurerm. Tous les secrets de connexion à la machine virtuelle du déployeur sont disponibles dans un coffre de clés dans le groupe de ressources du déployeur.

Pour vous connecter à votre machine virtuelle de déploiement :

Connectez-vous au portail Azure.
Sélectionnez ou recherchez Key Vaults.
Dans la page Coffre de clés , recherchez le coffre de clés du déployeur. Le nom commence par LAB[REGION]DEP05user. Filtrez par groupe de ressources ou emplacement, si nécessaire.
Dans la section Paramètres du volet gauche, sélectionnez Secrets.
Recherchez et sélectionnez le secret qui contient sshkey. Il pourrait ressembler à LAB-[REGION]-DEP05-sshkey.
Dans la page du secret, sélectionnez la version actuelle. Ensuite, copiez la valeur secrète.
Ouvrez un éditeur de texte brut. Copiez la valeur secrète.
Enregistrez le fichier dans lequel vous conservez des clés SSH. Par exemple, utilisez C:\\Users\\<your-username>\\.ssh.
Enregistrez le fichier. Si vous êtes invité à enregistrer en tant que type, sélectionnez Tous les fichiers si SSH n’est pas une option. Par exemple, utilisez deployer.ssh.
Connectez-vous à la machine virtuelle du déployeur via n’importe quel client SSH, tel que Visual Studio Code. Utilisez l’adresse IP publique que vous avez notée précédemment et la clé SSH que vous avez téléchargée. Pour obtenir des instructions sur la connexion au deployer à l’aide de Visual Studio Code, consultez Connecter au deployer à l’aide de Visual Studio Code. Si vous utilisez PuTTY, convertissez d’abord le fichier de clé SSH à l’aide de PuTTYGen.

Note

Le nom d’utilisateur par défaut est azureadm.

Assurez-vous que le fichier que vous utilisez pour enregistrer la clé SSH peut enregistrer le fichier à l’aide du format approprié, autrement dit, sans caractères de retour chariot (CR). Utilisez Visual Studio Code ou un éditeur de texte de base.

Une fois connecté à la machine virtuelle du déployeur, vous pouvez télécharger le logiciel SAP à l’aide de la facture de documents (BOM).

Connectez-vous à la machine virtuelle du déployeur lorsque vous n’utilisez pas d’adresse IP publique

Pour les déploiements sans connectivité IP publique, la connectivité directe via Internet n’est pas autorisée. Dans ce cas, vous pouvez utiliser une Azure Bastion jump box ou effectuer l’étape suivante à partir d’un ordinateur disposant d’une connectivité au réseau virtuel Azure.

L’exemple suivant utilise Azure Bastion.

Pour vous connecter au déployeur :

Connectez-vous au portail Azure.
Accédez au groupe de ressources qui contient la machine virtuelle du déployeur.
Connectez-vous à la machine virtuelle à l’aide de Azure Bastion.
Le nom d’utilisateur par défaut est azureadm.
Sélectionnez SSH Private Key dans Azure Key Vault.
Sélectionnez l’abonnement qui contient le plan de contrôle.
Sélectionnez le coffre de clés du système de déploiement.
Dans la liste des secrets, sélectionnez le secret qui se termine par -sshkey.
Connectez-vous à la machine virtuelle.

Le reste des tâches doit être exécuté sur le déployeur.

Sécuriser le plan de contrôle

Le plan de contrôle est la partie la plus critique de l’infrastructure d’automatisation SAP. Il est important de sécuriser le plan de contrôle. Les étapes suivantes vous aident à sécuriser le plan de contrôle.

Vous devez mettre à jour le fichier du plan tfvars de contrôle pour activer les points de terminaison privés et bloquer l’accès public aux comptes de stockage et aux coffres de clés.

Pour copier les fichiers de configuration du plan de contrôle sur la machine virtuelle du déployeur, vous pouvez utiliser le sync_deployer.sh script. Connectez-vous à la machine virtuelle du déployeur et mettez à jour la commande suivante pour utiliser le nom de votre compte de stockage d’état Terraform. Exécutez ensuite le script suivant :
```
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
```
Cette commande copie les tfvars fichiers de configuration du compte de stockage de la bibliothèque SAP vers la machine virtuelle du déployeur.

Remplacez les fichiers de configuration du plan de contrôle par :

# 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

Réexécutez le déploiement pour appliquer les modifications. Mettez à jour le nom du compte de stockage et le nom du coffre de clés dans le script.

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

Créez le déployeur et la bibliothèque SAP.

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

Déployer l’application web

Vous pouvez déployer l’application web à l’aide du script suivant :

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

Collecter des informations sur la zone de charge de travail

Collectez les informations suivantes dans un éditeur de texte. Ces informations ont été collectées à la fin de la phase « Déployer le plan de contrôle ».
1. Nom du compte de stockage de fichiers d’état Terraform dans le groupe de ressources de bibliothèque :
  1. À partir de l’exemple précédent, le groupe de ressources est LAB-SECE-SAP_LIBRARY.
  2. Le nom du compte de stockage contient labsecetfstate.
2. Nom du coffre de clés dans le groupe de ressources de l’éditeur de déploiement :
  1. À partir de l’exemple précédent, le groupe de ressources est LAB-SECE-DEP05-INFRASTRUCTURE.
  2. Le nom du coffre de clés contient LABSECEDEP05user.
3. Adresse IP publique de la machine virtuelle du déployeur. Accédez au groupe de ressources de votre déployeur, ouvrez la machine virtuelle du déployeur et copiez l’adresse IP publique.
Vous devez collecter les informations suivantes :
1. Le nom du fichier d’état du déployeur se trouve sous le groupe de ressources de bibliothèque :
  1. Sélectionnez groupe de ressources de la bibliothèque>compte de stockage d'état>Conteneurs>tfstate. Copiez le nom du fichier d’état du déployeur.
  2. À partir de l’exemple précédent, le nom de l’objet blob est LAB-SECE-DEP05-INFRASTRUCTURE.terraform.tfstate.

Si nécessaire, inscrivez le principal de service. Pour cet exemple, cette étape n’est pas nécessaire.

La première fois qu’un environnement est instancié, un principal de service doit être inscrit. Dans cet exemple, le plan de contrôle se trouve dans l’environnement LAB et la zone de charge de travail est également dans LAB. Pour cette raison, un principal de service doit être enregistré pour l’environnement LAB.

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

Préparer le déploiement de zone de charge de travail

Connectez-vous à votre machine virtuelle de déploiement pour les étapes suivantes. Une copie du dépôt est maintenant là.

Déployer la zone de charge de travail

Utilisez le script install_workloadzone pour déployer la zone de charge de travail SAP.

Sur la machine virtuelle du déployeur, accédez au Azure_SAP_Automated_Deployment dossier.

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

Si nécessaire, ouvrez le fichier de configuration de zone de charge de travail et, si nécessaire, modifiez le nom logique réseau pour qu’il corresponde au nom du réseau.

Démarrez le déploiement de la zone de charge de travail. Les détails que vous avez collectés précédemment sont nécessaires ici :

Nom du fichier du déployeur tfstate (trouvé dans le tfstate conteneur)
Nom du tfstate compte de stockage
Nom du coffre de clés du deployer

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

Le déploiement de zone de charge de travail doit démarrer automatiquement.

Attendez que le déploiement se termine. Le nouveau groupe de ressources apparaît dans le portail Azure.

Préparer le déploiement de l’infrastructure système SAP

Connectez-vous à votre machine virtuelle de déploiement pour les étapes suivantes. Une copie du dépôt est maintenant là.

Accédez au WORKSPACES/SYSTEM dossier et copiez les exemples de fichiers de configuration à utiliser à partir du référentiel.

Déployer l’infrastructure système SAP

Une fois la zone de charge de travail terminée, vous pouvez déployer les ressources de l’infrastructure système SAP. Le système SAP crée vos machines virtuelles et composants de prise en charge pour votre application SAP. Utilisez le script installer.sh pour déployer le système SAP.

Le système SAP déploie :

Niveau de base de données, qui déploie des machines virtuelles de base de données et leurs disques et une instance de Azure Standard Load Balancer. Vous pouvez exécuter des bases de données HANA ou des bases de données AnyDB dans ce niveau.
Le niveau SCS, qui déploie un nombre défini par le client de machines virtuelles et une instance de Azure Standard Load Balancer.
Niveau application, qui déploie les machines virtuelles et leurs disques.
Niveau Web Dispatcher.

Déployez le système SAP :

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

Vérifiez que le groupe de ressources système se trouve maintenant dans le portail Azure.

Obtenir un logiciel SAP à l’aide de la facture de documents

Le cadre d'automatisation vous donne des outils pour télécharger des logiciels à partir de SAP à l'aide de la BOM SAP. Le logiciel est téléchargé dans la bibliothèque SAP, qui joue le rôle d’archive pour tous les supports requis pour déployer SAP.

Le boM SAP imite le planificateur de maintenance SAP. Il existe des identificateurs de produit pertinents et un ensemble d’URL de téléchargement.

Un exemple d’extraction d’un fichier BOM ressemble à cet exemple :


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

Pour cet exemple de configuration, le groupe de ressources est LAB-SECE-DEP05-INFRASTRUCTURE. Le nom du coffre de clés du déployeur contient LABSECEDEP05user. Vous utilisez ces informations pour configurer les secrets du coffre-fort de clés de votre déployeur.

Connectez-vous à votre machine virtuelle de déploiement pour les étapes suivantes. Une copie du dépôt est maintenant là.
Ajoutez un secret avec le nom d’utilisateur de votre compte d’utilisateur SAP. Remplacez <vaultName> par le nom de votre clé dans azure key vault. Remplacez également <sap-username> par votre nom d'utilisateur SAP.
```
export key_vault=<vaultName>
export sap_username=<sap-username>

az keyvault secret set --name "S-Username" --vault-name $key_vault --value "${sap_username}";
```
Ajoutez un secret avec le mot de passe de votre compte d’utilisateur SAP. Remplacez <vaultName> par le nom de votre coffre de clés de déploiement et remplacez-le <sap-password> par votre mot de passe SAP.

Note

L’utilisation de guillemets simples lorsque vous définissez sap_user_password est importante. L’utilisation de caractères spéciaux dans le mot de passe peut entraîner des résultats imprévisibles.
```
sap_user_password='<sap-password>'

az keyvault secret set --name "S-Password" --vault-name "${key_vault}" --value="${sap_user_password}";
```
Configurez votre fichier de paramètres SAP pour le processus de téléchargement. Ensuite, téléchargez le logiciel SAP à l’aide de playbooks Ansible. Exécutez les commandes suivantes :
```
cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
mkdir BOMS
cd BOMS

vi sap-parameters.yaml
```
Mettez à jour le bom_base_name avec le nom BOM. Remplacez <Deployer KeyVault Name> par le nom du Azure Key Vault du groupe de ressources du déployeur.

Votre fichier doit ressembler à l’exemple de configuration suivant :
```
bom_base_name:                 S42022SPS00_v0001ms
deployer_kv_name:              <vaultName>
BOM_directory:                 ${HOME}/Azure_SAP_Automated_Deployment/samples/SAP
```
Pour télécharger le logiciel, exécutez le playbook Ansible. Une façon d’exécuter les playbooks consiste à utiliser le menu Téléchargeur. Exécutez le download_menu script.
```
${HOME}/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/download_menu.sh
```

Sélectionnez les playbooks à exécuter.

1) BoM Downloader
3) Quit
Please select playbook:

Sélectionnez le playbook 1) BoM Downloader pour télécharger le logiciel SAP décrit dans le fichier BOM sur le compte de stockage. Vérifiez que le sapbits conteneur dispose de tous vos supports pour l’installation.

Vous pouvez exécuter le playbook à l’aide du menu de configuration ou directement à partir de la ligne de commande.

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

Si vous le souhaitez, vous pouvez également transmettre les informations d’identification de l’utilisateur SAP en tant que paramètres.

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

Installer l’application SAP

L’installation de l’application SAP se produit via des playbooks Ansible.

Accédez au dossier de déploiement du système.

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

Vérifiez que vous disposez des fichiers suivants dans les dossiers actuels : sap-parameters.yaml et L00_host.yaml.

Pour un système SAP S/4HANA autonome, il existe huit playbooks à exécuter en séquence. Une façon d’exécuter les playbooks consiste à utiliser le menu de configuration.

Exécutez le configuration_menu script.

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

Choisissez les playbooks à exécuter.

Playbook : Configuration du système d’exploitation de base

Ce playbook effectue la configuration du système d’exploitation générique sur toutes les machines, notamment la configuration des référentiels logiciels, des packages et des services.