Tutoriel : déployer l’Infrastructure d’automatisation du déploiement SAP pour la mise à l'échelle de l’entreprise

Article
03/19/2024

Ce tutoriel vous montre comment effectuer des déploiements à l’aide de Infrastructure d’automatisation du déploiement SAP. Cet exemple utilise Azure Cloud Shell pour déployer l’infrastructure du plan de contrôle. La machine virtuelle du déploiement crée l’infrastructure et les configurations de SAP HANA restantes.

Dans ce didacticiel, vous allez effectuer les tâches suivantes :

Déployez le plan de contrôle (infrastructure et bibliothèque du système de déploiement).
Déployez la zone de charge de travail (paysage et système).
Téléchargez/Chargez la nomenclature.
Configurer les paramètres du système d’exploitation standards et spécifiques à SAP.
Installez la base de données HANA.
Installer le serveur des services centraux SAP (SCS).
Chargez la base de données HANA.
Installez le serveur d’applications principal.

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 SAP Automation dans une région Azure spécifiée. Au cours de 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 stockage partagé pour le support d’installation SAP.
Préparez la zone de charge de travail. Vous déployez les composants de zone de charge de travail, tels que le réseau virtuel et les coffres de clés.
Déployer 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. Ce didacticiel 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. Ce didacticiel décrit la hiérarchie générale et les différentes phases du déploiement.

Vue d’ensemble de l’environnement

L’infrastructure d’automatisation du déploiement SAP comprend deux composants principaux :

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

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

Diagram that shows the DevOps tutorial infrastructure design.

L’infrastructure utilise Terraform pour le déploiement d’infrastructure et Ansible pour la configuration des systèmes 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.

Diagram that shows the SAP Deployment Automation Framework environment.

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 redéployer, voire jamais.

Diagram that shows the control plane.

Le système de déploiement est le moteur d’exécution du framework d’automatisation de SAP. Cette machine virtuelle préconfigurée est utilisée pour l’exécution 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éploiement et la bibliothèque dans un fichier de variables 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éveloppement. Par exemple, vous pouvez avoir des niveaux de développement, d’assurance qualité et de production. L’infrastructure d’automatisation du déploiement SAP sur Azure nomme ces niveaux zones de charge de travail.

Diagram that shows the workload zone.

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

Le déploiement du système est constitué des machines virtuelles qui exécutent l’application SAP, y compris les niveaux web, application et base de données. Pour plus d’informations, consultez Configurer le système SAP.

Prérequis

Le référentiel de l’infrastructure d’automatisation de déploiement SAP est disponible sur GitHub.

Vous devez déployer Azure Bastion ou utiliser un client Secure Shell (SSH) pour vous connecter au déploiement. Utilisez n’importe quel client SSH qui vous convient.

Passer en revue le quota d’abonnement Azure

Assurez-vous que votre abonnement Azure possède un devis de base suffisant pour la référence SKU de la famille DdSV4 EdsV4 dans la région élue. Environ 50 cœurs disponible pour chaque famille de machines virtuelles doivent suffire.

S-compte d’utilisateur pour le téléchargement de logiciels SAP

Un compte d’utilisateur SAP valide (compte SAP-utilisateur ou S-Utilisateur) avec des privilèges de téléchargement de logiciels est requis pour télécharger le logiciel SAP.

Configurer 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’y êtes pas invité.

Vérifiez que 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

Ou :

az account list --output=table | grep True

Si nécessaire, changez 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

(Facultatif) Supprimez tous les artefacts de déploiement. Utilisez cette commande quand vous voulez supprimer tous les restes des artefacts de déploiements 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

(Facultatif) Validez les versions de Terraform et Azure CLI disponibles sur votre instance du Cloud Shell.
```
./sap-automation/deploy/scripts/helpers/check_workstation.sh
```
Pour exécuter l’infrastructure d’automatisation, mettez à 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 principal du service

L’infrastructure de déploiement SAP Automation utilise des principaux de service pour le déploiement. Créez un principal de service pour le déploiement de votre plan de contrôle. Veillez à utiliser un compte disposant des autorisations nécessaires pour créer des principaux de service.

Lorsque vous choisissez le nom de votre principal de service, assurez-vous que le nom est unique au sein de votre locataire Azure.

Donnez au contributeur principal du service et à l’utilisateur des privilèges d’administrateur.

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 la sortie. Par exemple :

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

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

La sortie est mappée 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 de l’accès utilisateur au principal de service, vous ne pouvez pas attribuer d’autorisations à l’aide de l’automatisation.

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

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

Screenshot that shows the web app front page.

Créer une inscription d’application

Si vous voulez 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 LAB par votre environnement, si nécessaire.

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

Remarque

Assurez-vous que vous êtes connecté à l'aide d'un compte d'utilisateur disposant des autorisations nécessaires pour créer des enregistrements d'applications. Pour plus d’informations sur les inscriptions d’applications, consultez Créer une inscription d’application.

Copiez les détails de la sortie. Assurez-vous d’enregistrer les valeurs pour App registration ID et App registration password.

La sortie est mappée 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 répertoire WORKSPACES. Il existe six sous-dossiers : CONFIGURATION, DEPLOYER, LANDSCAPE, LIBRARY, SYSTEM et BOMS. Développez chacun de ces dossiers pour rechercher les fichiers de configuration de déploiement régionaux.

Recherchez les fichiers de variables Terraform dans le sous-dossier approprié. Par exemple, le fichier de variables Terraform du DEPLOYER peut se présenter comme 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 futures modifications au cours du déploiement.

Recherchez les fichiers de variables Terraform de la bibliothèque SAP dans le sous-dossier approprié. Par exemple, le fichier de variables Terraform du LIBRARY peut se présenter comme 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 futures modifications au cours du déploiement.

Important

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

Déployer le plan de contrôle

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

Le système de déploiement passe par des cycles de déploiement de l’infrastructure, d’actualisation de l’état et de télé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 le responsable du système de déploiement et de la bibliothèque, ainsi que d’autres paramètres.

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

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

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 depuis une station de travail qui ne fait pas partie du réseau de déploiement ou depuis Cloud Shell, vous pouvez utiliser la commande suivante afin de 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 le déployeur et la Bibliothèque SAP, puis ajoutez les détails du principal de service au coffre de clés de déploiement en utilisant 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 désactivez le token-cache. Ensuite, exécutez az login pour vous authentifier à nouveau.

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

Le déploiement du système de déploiement 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 les nouveaux groupes de ressources pour l’infrastructure et la bibliothèque du déploiement. Par exemple, vous pouvez voir LAB-[region]-DEP05-INFRASTRUCTURE et LAB-[region]-SAP_LIBRARY.

Le contenu du groupe de ressources du déploiement et de la Bibliothèque SAP est présenté 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 de déploiement et d’état de la bibliothèque. Le contenu du conteneur tfstate après un déploiement de plan de contrôle réussi peut être consulté apparaît ici.

Problèmes courants et solutions

Voici quelques conseils pour la résolution de ce problème :

Si vous recevez l’erreur suivante pour la création du module de déploiement, vérifiez que vous êtes dans le répertoire WORKSPACES 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 l’exécution du script deploy_controlplane.sh, exécutez cette commande :
```
az logout

az login
```

Se connecter à la machine virtuelle du système de déploiement

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

Pour vous connecter à la machine virtuelle de votre système de déploiement :

Connectez-vous au portail Azure.
Sélectionnez ou recherchez des coffres de clés.
Dans la page du coffre de clés, recherchez le coffre de clés du déploiement. Le &om commence par LAB[REGION]DEP05user. Filtrez par le Groupe de ressources ou l’Emplacement si nécessaire.
Dans la section Paramètres du volet gauche, sélectionnez Secrets.
Recherchez et sélectionnez le secret contenant sshkey. Il peut se présenter comme suit : LAB-[REGION]-DEP05-sshkey.
Sur la page du secret, sélectionnez la version actuelle. Ensuite, copiez la valeur du secret.
Ouvrez un éditeur de texte brut. Copiez dans la valeur de secret.
Enregistrez le fichier dans lequel vous conservez les 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 système de déploiement via un 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 système de déploiement à l’aide de Visual Studio Code, consultez Se connecter au déploiement à l’aide de Visual Studio Code. Si vous utilisez PuTTY, convertissez d’abord le fichier de clé SSH à l’aide de PuTTYGen.

Remarque

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

Vérifiez que le fichier que vous utilisez pour enregistrer la clé SSH peut enregistrer le fichier en utilisant le format approprié, c’est-à-dire sans caractères de retour charriot (CR). Utilisez Visual Studio Code ou Notepad++.

Après vous être connecté à la machine virtuelle système de déploiement, vous pouvez télécharger le logiciel SAP à l’aide de la nomenclature.

Se connecter à la machine virtuelle du système de déploiement 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. Vous pouvez alors utiliser Azure Bastion, avoir recours à un serveur de rebond ou suivre l’étape ci-dessous à partir d’un ordinateur connecté au réseau virtuel Azure.

L’exemple suivant utilise Azure Bastion.

Pour se connecter au système de déploiement :

Connectez-vous au portail Azure.
Accédez au groupe de ressources contenant la machine virtuelle du système de déploiement.
Connectez-vous à la machine virtuelle en utilisant Azure Bastion.
Le nom d’utilisateur par défaut est azureadmin.
Sélectionnez Clé privée SSH d’Azure Key Vault.
Sélectionnez l’abonnement contenant 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 système de déploiement.

Sécurisez 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 tfvars du plan de contrôle pour activer les points de terminaison privés, et pour 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 dans la machine virtuelle du déployeur, vous pouvez utiliser le script sync_deployer.sh. 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 permet de copier les fichiers de configuration tfvars du compte de stockage de la bibliothèque SAP vers la machine virtuelle du déployeur.

Remplacer 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 en utilisant le 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 les informations de 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 de « déploiement du plan de contrôle ».
1. Nom du compte de stockage de fichiers d’état Terraform dans le groupe de ressources de bibliothèque :
  - Comme dans l’exemple précédent, le groupe de ressources est LAB-SECE-SAP_LIBRARY.
  - Le nom du compte de stockage contient labsecetfstate.
2. Le nom du coffre de clés dans le groupe de ressources du système de déploiement :
  - Comme dans l’exemple précédent, le groupe de ressources est LAB-SECE-DEP05-INFRASTRUCTURE.
  - Le nom du coffre de clés contient LABSECEDEP05user.
3. L’adresse IP publique de la machine virtuelle du système de déploiement. Accédez au groupe de ressources de votre déployeur, ouvrez la machine virtuelle du déployeur, puis copiez l’adresse IP publique.
Vous devez recueillir les informations suivantes :
1. Le nom du fichier d’état du déployeur se trouve sous le groupe de ressources de la bibliothèque :
  - Sélectionnez Groupe de ressources de la bibliothèque>Comptes de stockage d’état>Conteneurs>tfstate. Copiez le nom du fichier d’état du système de déploiement.
  - Comme dans 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 ce tutoriel, cette étape n'est pas nécessaire.

La première fois qu’un environnement est instancié, un principal de service doit être inscrit. Dans ce tutoriel, le plan de contrôle se trouve dans l’environnement LAB et la zone de la charge de travail se trouve également dans LAB. Pour cette raison, un principal de service doit donc être inscrit 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 la zone de charge de travail

Connecter à votre machine virtuelle de déploiement pour les étapes suivantes. Une copie du référentiel est désormais 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 système de déploiement, accédez au dossier Azure_SAP_Automated_Deployment.
```
cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LANDSCAPE/LAB-SECE-SAP04-INFRASTRUCTURE
```
(Facultatif) Ouvrez le fichier de configuration de la zone de charge de travail et, si nécessaire, modifiez le nom logique du réseau pour qu’il corresponde au nom du réseau.
Démarrer 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 tfstate du système de déploiement (trouvé dans le conteneur tfstate)
- Nom du compte de stockage tfstate
- Nom du coffre de clés du déployeur


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 la 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 du système SAP

Connecter à votre machine virtuelle de déploiement pour les étapes suivantes. Une copie du référentiel est désormais là.

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

Déployer l’infrastructure du système SAP

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

Le système SAP déploie :

La couche base de données, qui déploie les machines virtuelles de base de données, leurs disques et une instance 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 Standard Load Balancer Azure.
La couche application, qui déploie les machines virtuelles et leurs disques.
Le niveau Web Dispatcher.

Déployer 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 désormais dans la Portail Azure.

Obtenir le logiciel SAP à l’aide de la nomenclature

L’infrastructure d’automatisation vous offre des outils permettant de télécharger des logiciels à partir de SAP à l’aide de la nomenclature SAP. Le logiciel est téléchargé dans la Bibliothèque SAP qui sert d’archive pour tous les supports nécessaires au déploiement de SAP.

La nomenclature SAP imite le planificateur de maintenance SAP. Il existe des identificateurs de produits pertinents et un ensemble d’URL de téléchargement.

Voici un exemple d’extraction d’un fichier de nomenclature :


---
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éploiement contient LABSECEDEP05user dans le nom. Utilisez ces informations pour configurer les secrets de coffre de clés de votre déploiement.

Connecter à votre machine virtuelle de déploiement pour les étapes suivantes. Une copie du référentiel est désormais 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 <sap-username> par votre nom d'utilisateur SAP.
```
export key_vault=<vaultName>
    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 <sap-password> par votre mot de passe SAP.

Remarque

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. Enfin, téléchargez le logiciel SAP à l’aide des 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 nom BOM. Remplacez <Deployer KeyVault Name> par le nom du coffre de clés Azure pour le groupe de ressources du déployeur.

Votre fichier JSON doit être semblable à l'exemple de configuration suivant :
```
bom_base_name:                 S42022SPS00_v0001ms
deployer_kv_name:              <vaultName>
BOM_directory:                 ${HOME}/Azure_SAP_Automated_Deployment/samples/SAP
```
Exécutez le playbook Ansible pour télécharger le logiciel. L’une des méthodes permettant d’exécuter les playbooks consiste à utiliser le menu Téléchargeur. Exécutez le script download_menu.
```
${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 de nomenclature dans le compte de stockage. Vérifiez que le conteneur sapbits dispose de tous vos éléments multimédias pour l’installation.

Vous pouvez exécuter le guide opérationnel en utilisant le 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 aussi passer 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

Installation de l'application SAP

L’installation de l’application SAP s’effectue par le biais de 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 actifs : sap-parameters.yaml et L00_host.yaml.

Pour un système SAP S/4HANA autonome, il y a huit règles à exécuter en séquence. L’une des méthodes permettant d’exécuter les guides opérationnels consiste à utiliser le menu de configuration.

Exécutez le script configuration_menu.

${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 guide opérationnel effectue la configuration du système d’exploitation générique sur toutes les machines, qui inclut la configuration des référentiels de logiciels, des packages et des services.