Share via

Esercitazione: Distribuire SAP Deployment Automation Framework per la scalabilità aziendale

  • Articolo

Questa esercitazione illustra come eseguire distribuzioni usando SAP Deployment Automation Framework. Questo esempio usa Azure Cloud Shell per distribuire l'infrastruttura del piano di controllo. La macchina virtuale di distribuzione crea l'infrastruttura rimanente e le configurazioni SAP HANA.

In questa esercitazione si eseguono le seguenti attività:

  • Distribuire il piano di controllo (infrastruttura e libreria del deployer).
  • Distribuire la zona del carico di lavoro (orizzontale e sistema).
  • Scarica/Carica materiale.
  • Configurare le impostazioni del sistema operativo standard e specifiche di SAP.
  • Installare il database HANA.
  • Installare il server SAP Central Services (SCS).
  • Caricare il database HANA.
  • Installare il server applicazioni primario.

Esistono tre passaggi principali di una distribuzione SAP in Azure con il framework di automazione:

  1. Preparare l'area. I componenti vengono distribuiti per supportare il framework di automazione SAP in un'area di Azure specificata. In questo passaggio:

    1. Creare l'ambiente di distribuzione.
    2. Creare una risorsa di archiviazione condivisa per i file di stato di Terraform.
    3. Creare l'archiviazione condivisa per i supporti di installazione SAP.

  2. Preparare la zona del carico di lavoro. Si distribuiscono i componenti della zona del carico di lavoro, ad esempio la rete virtuale e gli insiemi di credenziali delle chiavi.

  3. Distribuire il sistema. Si distribuisce l'infrastruttura per il sistema SAP.

Esistono diversi flussi di lavoro nel processo di automazione della distribuzione. Questa esercitazione è incentrata su un flusso di lavoro per semplificare la distribuzione. È possibile distribuire questo flusso di lavoro, l'ambiente autonomo SAP S4 HANA, usando Bash. Questa esercitazione descrive la gerarchia generale e le diverse fasi della distribuzione.

Panoramica dell'ambiente

SAP Deployment Automation Framework include due componenti principali:

  • Infrastruttura di distribuzione (piano di controllo)
  • Infrastruttura SAP (carico di lavoro SAP)

Il diagramma seguente illustra la dipendenza tra il piano di controllo e il piano applicazione.

Diagram that shows the DevOps tutorial infrastructure design.

Il framework usa Terraform per la distribuzione dell'infrastruttura e Ansible per il sistema operativo e la configurazione dell'applicazione. Il diagramma seguente illustra la separazione logica del piano di controllo e della zona del carico di lavoro.

Diagram that shows the SAP Deployment Automation Framework environment.

Area di gestione

La zona di gestione contiene l'infrastruttura del piano di controllo da cui vengono distribuiti altri ambienti. Dopo la distribuzione della zona di gestione, raramente, è necessario ridistribuire.

Diagram that shows the control plane.

Il deployer è il motore di esecuzione del framework di automazione SAP. Questa macchina virtuale preconfigurata viene usata per l'esecuzione di comandi Terraform e Ansible.

La libreria SAP fornisce l'archiviazione permanente per i file di stato terraform e il supporto di installazione SAP scaricato per il piano di controllo.

Configurare il deployer e la libreria in un file di variabile Terraform .tfvars . Per altre informazioni, vedere Configurare il piano di controllo.

Zona del carico di lavoro

Un'applicazione SAP ha in genere più livelli di distribuzione. Ad esempio, si potrebbero avere livelli di sviluppo, controllo qualità e produzione. SAP Deployment Automation Framework chiama queste zone del carico di lavoro di livelli.

Diagram that shows the workload zone.

L'area del carico di lavoro SAP contiene i componenti di rete e condivisi per le macchine virtuali SAP. Questi componenti includono tabelle di route, gruppi di sicurezza di rete e reti virtuali. Il panorama offre la possibilità di dividere le distribuzioni in ambienti diversi. Per altre informazioni, vedere Configurare l'area del carico di lavoro.

La distribuzione di sistema è costituita dalle macchine virtuali per eseguire l'applicazione SAP, inclusi i livelli Web, app e database. Per altre informazioni, vedere Configurare il sistema SAP.

Prerequisiti

Il repository SAP Deployment Automation Framework è disponibile in GitHub.

È necessario distribuire Azure Bastion o usare un client SSH (Secure Shell) per connettersi al deployer. Usare qualsiasi client SSH con cui ci si sente a proprio agio.

Esaminare la quota di sottoscrizione di Azure

Assicurarsi che la sottoscrizione di Azure disponga di un'offerta core sufficiente per gli SKU della famiglia DdSV4 ed EdsV4 nell'area selezionata. Circa 50 core disponibili per ogni famiglia di macchine virtuali dovrebbero essere sufficienti.

Download dell'account S-User per il software SAP

Per scaricare il software SAP, è necessario un account utente SAP (utente SAP o account utente S-User) valido con privilegi di download software.

Configurare Cloud Shell

  1. Passare ad Azure Cloud Shell.

  2. Accedere all'account di Azure.

    az login

    Autenticare l'accesso. Non chiudere la finestra finché non viene richiesto.

  3. Convalidare la sottoscrizione attiva e registrare l'ID sottoscrizione:

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

    Oppure:

    az account list --output=table | grep True

  4. Se necessario, modificare la sottoscrizione attiva.

    az account set --subscription <Subscription ID>

    Verificare che la sottoscrizione attiva sia stata modificata.

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

  5. Facoltativamente, rimuovere tutti gli artefatti di distribuzione. Usare questo comando quando si desidera rimuovere tutti i resti degli artefatti di distribuzione precedenti.

    
cd ~

rm -rf Azure_SAP_Automated_Deployment .sap_deployment_automation .terraform.d

  6. Creare la cartella di distribuzione e clonare il 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

  7. Facoltativamente, convalidare le versioni di Terraform e l'interfaccia della riga di comando di Azure disponibili nell'istanza di Cloud Shell.

    ./sap-automation/deploy/scripts/helpers/check_workstation.sh

    Per eseguire il framework di automazione, eseguire l'aggiornamento alle versioni seguenti:

Creare un'entità servizio

Il framework di distribuzione di automazione SAP usa le entità servizio per la distribuzione. Creare un'entità servizio per la distribuzione del piano di controllo. Assicurarsi di usare un account con le autorizzazioni per creare entità servizio.

Quando si sceglie un nome per l'entità servizio, assicurarsi che il nome sia univoco all'interno del tenant di Azure.

  1. Concedere all'entità servizio le autorizzazioni collaboratore e accesso utente Amministrazione istrator.

    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"

    Esaminare l'output. Ad esempio:

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

  2. Copiare i dettagli dell'output. Assicurarsi di salvare i valori per appId, passworde Tenant.

    L'output esegue il mapping ai parametri seguenti. Questi parametri vengono usati nei passaggi successivi, con i comandi di automazione.

    Nome dell'input del parametro Nome output
    spn_id appId
    spn_secret password
    tenant_id tenant

  3. Facoltativamente, assegnare il ruolo accesso utente Amministrazione istrator all'entità servizio.

    export appId="<appId>"

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

Importante

Se non si assegna il ruolo Accesso utenti Amministrazione istrator all'entità servizio, non è possibile assegnare autorizzazioni usando l'automazione.

Configurare le credenziali dell'applicazione Web del piano di controllo

Come parte del piano di controllo del framework di automazione SAP, è possibile creare facoltativamente un'applicazione Web interattiva che consente di creare i file di configurazione necessari.

Screenshot that shows the web app front page.

Creare una registrazione app

Se si vuole usare l'app Web, è prima necessario creare una registrazione dell'app a scopo di autenticazione. Aprire Cloud Shell ed eseguire i comandi seguenti:

Sostituire LAB con l'ambiente, se necessario.

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

Nota

Assicurarsi di aver eseguito l'accesso usando un account utente con le autorizzazioni necessarie per creare registrazioni dell'applicazione. Per altre informazioni sulle registrazioni delle app, vedere Creare una registrazione dell'app.

Copiare i dettagli dell'output. Assicurarsi di salvare i valori per App registration ID e App registration password.

L'output esegue il mapping ai parametri seguenti. Questi parametri vengono usati nei passaggi successivi, con i comandi di automazione.

Nome dell'input del parametro Nome output
app_registration_app_id App registration ID
webapp_client_secret App registration password

Visualizzare i file di configurazione

  1. Aprire Visual Studio Code da Cloud Shell.

    cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
code .

  2. Espandere la WORKSPACES directory. Sono disponibili sei sottocartelle: CONFIGURATION, DEPLOYER, LANDSCAPE, LIBRARY, SYSTEMe BOMS. Espandere ognuna di queste cartelle per trovare i file di configurazione della distribuzione a livello di area.

  3. Trovare i file di variabile Terraform nella sottocartella appropriata. Ad esempio, il file di DEPLOYER variabile Terraform potrebbe essere simile all'esempio seguente:

    # 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

    Si notino i percorsi dei file delle variabili Terraform per le modifiche future durante la distribuzione.

  4. Trovare i file di variabile Terraform per la libreria SAP nella sottocartella appropriata. Ad esempio, il file di LIBRARY variabile Terraform potrebbe essere simile all'esempio seguente:

    # 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

    Si notino i percorsi dei file delle variabili Terraform per le modifiche future durante la distribuzione.

Importante

Assicurarsi che corrisponda all'istanza dns_label di Azure DNS privato.

Distribuire il piano di controllo

Usare lo script deploy_controlplane.sh per distribuire il deployer e la libreria. Questi componenti di distribuzione costituiscono il piano di controllo per un'area di automazione scelta.

La distribuzione passa attraverso cicli di distribuzione dell'infrastruttura, aggiornamento dello stato e caricamento dei file di stato Terraform nell'account di archiviazione della libreria. Tutti questi passaggi vengono inseriti in un unico script di distribuzione. Lo script richiede il percorso del file di configurazione per il deployer e la libreria e altri parametri.

Ad esempio, scegliere Europa occidentale come percorso di distribuzione, con il nome SECEa quattro caratteri , come descritto in precedenza. Il file LAB-SECE-DEP05-INFRASTRUCTURE.tfvars di configurazione del deployer di esempio si trova nella ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/LAB-SECE-DEP05-INFRASTRUCTURE cartella .

Il file LAB-SECE-SAP_LIBRARY.tfvars di configurazione della libreria SAP di esempio si trova nella ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/LAB-SECE-SAP_LIBRARY cartella .

  1. Impostare le variabili di ambiente per l'entità servizio:

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

    Se si esegue lo script da una workstation che non fa parte della rete di distribuzione o da Cloud Shell, è possibile usare il comando seguente per impostare la variabile di ambiente per consentire la connettività dall'indirizzo IP:

    export TF_VAR_Agent_IP=<your-public-ip-address>

    Se si distribuisce l'applicazione Web di configurazione, è necessario impostare anche le variabili di ambiente seguenti:

    
export TF_VAR_app_registration_app_id=<appRegistrationId>
export    TF_VAR_webapp_client_secret=<appRegistrationPassword>
export                  TF_use_webapp=true

  2. Creare il deployer e la libreria SAP e aggiungere i dettagli dell'entità servizio all'insieme di credenziali delle chiavi di distribuzione usando questo 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}"

    Se si verificano problemi di autenticazione, eseguire az logout per disconnettersi e cancellare .token-cache az login Eseguire quindi per ripetere l'autenticazione.

    Attendere che il framework di automazione esegua le operazioni plan terraform e apply.

    La distribuzione del deployer può essere eseguita per circa 15-20 minuti.

    È necessario prendere nota di alcuni valori per i passaggi successivi. Cercare questo blocco di testo nell'output:

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

  3. Vai al portale di Azure.

    Selezionare Gruppi di risorse. Cercare nuovi gruppi di risorse per l'infrastruttura e la libreria del deployer. Ad esempio, è possibile visualizzare LAB-[region]-DEP05-INFRASTRUCTURE e LAB-[region]-SAP_LIBRARY.

    Il contenuto del gruppo di risorse deployer e della libreria SAP è illustrato qui.

    Screenshot that shows deployer resources.

    Screenshot that shows library resources.

    Il file di stato Terraform viene ora inserito nell'account di archiviazione il cui nome contiene tfstate. L'account di archiviazione ha un contenitore denominato tfstate con il deployer e i file di stato della libreria. Il contenuto del contenitore dopo una corretta distribuzione del tfstate piano di controllo è illustrato di seguito.

    Screenshot that shows the control plane Terraform state files.

Problemi noti e soluzioni

Ecco alcuni suggerimenti per la risoluzione dei problemi:

  • Se viene visualizzato l'errore seguente per la creazione del modulo deployer, assicurarsi di entrare nella WORKSPACES directory quando si esegue lo script:

    Incorrect parameter file.
The file must contain the environment attribute!!

  • L'errore seguente è temporaneo. Eseguire di nuovo lo stesso comando, deploy_controlplane.sh.

    Error: file provisioner error
..
timeout - last error: dial tcp

  • Se si verificano problemi di autenticazione direttamente dopo l'esecuzione dello script deploy_controlplane.sh, eseguire questo comando:

    az logout

az login

Connessione alla macchina virtuale del deployer

Dopo la distribuzione del piano di controllo, lo stato terraform viene archiviato usando il back-end azurermremoto . Tutti i segreti per la connessione alla macchina virtuale deployer sono disponibili in un insieme di credenziali delle chiavi nel gruppo di risorse del deployer.

Per connettersi alla macchina virtuale deployer:

  1. Accedere al portale di Azure.

  2. Selezionare o cercare Insiemi di credenziali delle chiavi.

  3. Nella pagina Insieme di credenziali delle chiavi trovare l'insieme di credenziali delle chiavi del deployer. Il nome inizia con LAB[REGION]DEP05user. Filtrare in base al gruppo di risorse o alla località, se necessario.

  4. Nella sezione Impostazioni nel riquadro sinistro selezionare Segreti.

  5. Trovare e selezionare il segreto che contiene sshkey. Potrebbe essere simile LAB-[REGION]-DEP05-sshkeya .

  6. Nella pagina del segreto selezionare la versione corrente. Copiare quindi il valore del segreto.

  7. Aprire un editor di testo normale. Copiare il valore del segreto.

  8. Salvare il file in cui si mantengono le chiavi SSH. Ad esempio, usare C:\\Users\\<your-username>\\.ssh.

  9. Salvare il file. Se viene richiesto di salvare con nome, selezionare Tutti i file se SSH non è un'opzione. Ad esempio, usare deployer.ssh.

  10. Connessione alla macchina virtuale di distribuzione tramite qualsiasi client SSH, ad esempio Visual Studio Code. Usare l'indirizzo IP pubblico annotato in precedenza e la chiave SSH scaricata. Per istruzioni su come connettersi al deployer usando Visual Studio Code, vedere Connessione al deployer usando Visual Studio Code. Se si usa PuTTY, convertire prima il file di chiave SSH usando PuTTYGen.

Nota

Il nome utente predefinito è azureadm.

Assicurarsi che il file usato per salvare la chiave SSH possa salvare il file usando il formato corretto, ovvero senza caratteri di ritorno a capo (CR). Usare Visual Studio Code o Blocco note++.

Dopo aver eseguito la connessione alla macchina virtuale del deployer, è possibile scaricare il software SAP usando la distinta base (Bill of Materials).

Connessione alla macchina virtuale di distribuzione quando non si usa un indirizzo IP pubblico

Per le distribuzioni senza connettività IP pubblico, la connettività diretta tramite Internet non è consentita. In questi casi, è possibile usare una jump box di Azure Bastion oppure eseguire il passaggio successivo da un computer con connettività alla rete virtuale di Azure.

L'esempio seguente usa Azure Bastion.

Per connettersi al deployer:

  1. Accedere al portale di Azure.

  2. Passare al gruppo di risorse che contiene la macchina virtuale del deployer.

  3. Connessione alla macchina virtuale usando Azure Bastion.

  4. Il nome utente predefinito è azureadm.

  5. Selezionare Chiave privata SSH da Azure Key Vault.

  6. Selezionare la sottoscrizione che contiene il piano di controllo.

  7. Selezionare l'insieme di credenziali delle chiavi del deployer.

  8. Nell'elenco dei segreti selezionare il segreto che termina con -sshkey.

  9. Connettersi alla VM.

Il resto delle attività deve essere eseguito nel deployer.

Proteggere il piano di controllo

Il piano di controllo è la parte più critica del framework di automazione SAP. È importante proteggere il piano di controllo. I passaggi seguenti consentono di proteggere il piano di controllo.

È necessario aggiornare il file del piano tfvars di controllo per abilitare gli endpoint privati e bloccare l'accesso pubblico agli account di archiviazione e agli insiemi di credenziali delle chiavi.

  1. Per copiare i file di configurazione del piano di controllo nella macchina virtuale deployer, è possibile usare lo sync_deployer.sh script. Accedere alla macchina virtuale deployer e aggiornare il comando seguente per usare il nome dell'account di archiviazione dello stato terraform. Eseguire quindi lo script seguente:

    
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

    Questo comando copia i tfvars file di configurazione dall'account di archiviazione della libreria SAP alla macchina virtuale deployer.

  2. Modificare i file di configurazione per il piano di controllo in:

    
    # 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

  3. Eseguire di nuovo la distribuzione per applicare le modifiche. Aggiornare il nome dell'account di archiviazione e il nome dell'insieme di credenziali delle chiavi nello script.

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

  4. Creare il deployer e la libreria 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}"

Distribuire l'applicazione Web

È possibile distribuire l'applicazione Web usando lo script seguente:

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

Raccogliere informazioni sulla zona del carico di lavoro

  1. Raccogliere le informazioni seguenti in un editor di testo. Queste informazioni sono state raccolte alla fine della fase "Distribuire il piano di controllo".

    1. Nome dell'account di archiviazione dei file di stato Terraform nel gruppo di risorse della libreria:

      • Seguendo l'esempio precedente, il gruppo di risorse è LAB-SECE-SAP_LIBRARY.
      • Il nome dell'account di archiviazione contiene labsecetfstate.

    2. Nome dell'insieme di credenziali delle chiavi nel gruppo di risorse del deployer:

      • Seguendo l'esempio precedente, il gruppo di risorse è LAB-SECE-DEP05-INFRASTRUCTURE.
      • Il nome dell'insieme di credenziali delle chiavi contiene LABSECEDEP05user.

    3. Indirizzo IP pubblico della macchina virtuale del deployer. Passare al gruppo di risorse del deployer, aprire la macchina virtuale deployer e copiare l'indirizzo IP pubblico.

  2. È necessario raccogliere le informazioni seguenti:

    1. Il nome del file di stato del deployer si trova nel gruppo di risorse della libreria:
      • Selezionare Libreria gruppo>di risorse Contenitoritfstate> dell'account>di archiviazione stato. Copiare il nome del file di stato del deployer.
      • Seguendo l'esempio precedente, il nome del BLOB è LAB-SECE-DEP05-INFRASTRUCTURE.terraform.tfstate.

  3. Se necessario, registrare l'entità servizio. Per questa esercitazione, questo passaggio non è necessario.

    La prima volta che viene creata un'istanza di un ambiente, è necessario registrare un'entità servizio. In questa esercitazione il piano di controllo si trova nell'ambiente LAB e la zona del carico di lavoro si trova anche in LAB. Per questo motivo, un'entità servizio deve essere registrata per l'ambiente 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}"

Preparare la distribuzione della zona del carico di lavoro

Connessione alla macchina virtuale del deployer per la procedura seguente. È ora disponibile una copia del repository.

Distribuire l'area del carico di lavoro

Usare lo script install_workloadzone per distribuire l'area del carico di lavoro SAP.

  1. Nella macchina virtuale deployer passare alla Azure_SAP_Automated_Deployment cartella .

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

  2. Facoltativamente, aprire il file di configurazione della zona del carico di lavoro e, se necessario, modificare il nome logico di rete in modo che corrisponda al nome di rete.

  3. Avviare la distribuzione della zona del carico di lavoro. I dettagli raccolti in precedenza sono necessari qui:

    • Nome del file deployer tfstate (disponibile nel tfstate contenitore)
    • Nome dell'account tfstate di archiviazione
    • Nome dell'insieme di credenziali delle chiavi del 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}"

La distribuzione della zona del carico di lavoro deve essere avviata automaticamente.

Attendere il completamento della distribuzione. Il nuovo gruppo di risorse viene visualizzato nella portale di Azure.

Preparare la distribuzione dell'infrastruttura di sistema SAP

Connessione alla macchina virtuale del deployer per la procedura seguente. È ora disponibile una copia del repository.

Passare alla WORKSPACES/SYSTEM cartella e copiare i file di configurazione di esempio da usare dal repository.

Distribuire l'infrastruttura di sistema SAP

Al termine dell'area del carico di lavoro, è possibile distribuire le risorse dell'infrastruttura di sistema SAP. Il sistema SAP crea le macchine virtuali e i componenti di supporto per l'applicazione SAP. Usare lo script installer.sh per distribuire il sistema SAP.

Il sistema SAP distribuisce:

  • Livello di database, che distribuisce le macchine virtuali di database e i relativi dischi e un'istanza di Azure Load Balancer Standard. È possibile eseguire database HANA o database AnyDB in questo livello.
  • Il livello SCS, che distribuisce un numero definito dal cliente di macchine virtuali e un'istanza di Azure Load Balancer Standard.
  • Il livello applicazione, che distribuisce le macchine virtuali e i relativi dischi.
  • Livello Dispatcher Web.

Distribuire il sistema 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

Verificare che il gruppo di risorse di sistema sia ora presente nella portale di Azure.

Ottenere il software SAP usando la distinta base dei materiali

Il framework di automazione offre strumenti per scaricare il software da SAP usando la distinta base SAP. Il software viene scaricato nella libreria SAP, che funge da archivio per tutti i supporti necessari per distribuire SAP.

SAP BOM simula lo strumento di pianificazione della manutenzione SAP. Sono presenti identificatori di prodotto pertinenti e un set di URL di download.

Un esempio di estrazione di un file BOM è simile all'esempio seguente:


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

Per questa configurazione di esempio, il gruppo di risorse è LAB-SECE-DEP05-INFRASTRUCTURE. Il nome dell'insieme di credenziali delle chiavi del deployer contiene LABSECEDEP05user nel nome. Queste informazioni vengono usate per configurare i segreti dell'insieme di credenziali delle chiavi del deployer.

  1. Connessione alla macchina virtuale del deployer per la procedura seguente. È ora disponibile una copia del repository.

  2. Aggiungere un segreto con il nome utente per l'account utente SAP. Sostituire <vaultName> con il nome dell'insieme di credenziali delle chiavi del deployer. <sap-username> Sostituire anche con il nome utente SAP.

    export key_vault=<vaultName>
    sap_username=<sap-username>

az keyvault secret set --name "S-Username" --vault-name $key_vault --value "${sap_username}";

  3. Aggiungere un segreto con la password per l'account utente SAP. Sostituire <vaultName> con il nome dell'insieme di credenziali delle chiavi del deployer e sostituire <sap-password> con la password SAP.

    Nota

    L'uso di virgolette singole quando si imposta sap_user_password è importante. L'uso di caratteri speciali nella password può altrimenti causare risultati imprevedibili.

    sap_user_password='<sap-password>'

az keyvault secret set --name "S-Password" --vault-name "${key_vault}" --value="${sap_user_password}";

  4. Configurare il file dei parametri SAP per il processo di download. Scaricare quindi il software SAP usando i playbook ansible. Eseguire i comandi seguenti:

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

vi sap-parameters.yaml

  5. bom_base_name Aggiornare con il nome BOM. Sostituire <Deployer KeyVault Name> con il nome dell'insieme di credenziali delle chiavi di Azure per il gruppo di risorse del deployer.

    Il file dovrebbe essere simile alla configurazione di esempio seguente:

    
bom_base_name:                 S42022SPS00_v0001ms
deployer_kv_name:              <vaultName>
BOM_directory:                 ${HOME}/Azure_SAP_Automated_Deployment/samples/SAP

  6. Eseguire il playbook ansible per scaricare il software. Un modo per eseguire i playbook consiste nell'usare il menu Downloader . Eseguire lo script download_menu.

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

  7. Selezionare i playbook da eseguire.

    1) BoM Downloader
3) Quit
Please select playbook:

    Selezionare il playbook 1) BoM Downloader per scaricare il software SAP descritto nel file BOM nell'account di archiviazione. Verificare che il sapbits contenitore disponga di tutti i supporti per l'installazione.

    È possibile eseguire il playbook usando il menu di configurazione o direttamente dalla riga di comando.

    
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

    Se si vuole, è anche possibile passare le credenziali utente SAP come parametri.

    
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

Installazione dell'applicazione SAP

L'installazione dell'applicazione SAP avviene tramite playbook ansible.

Passare alla cartella di distribuzione di sistema.

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

Assicurarsi di avere i file seguenti nelle cartelle correnti: sap-parameters.yaml e L00_host.yaml.

Per un sistema SAP S/4HANA autonomo, sono disponibili otto playbook da eseguire in sequenza. Un modo per eseguire i playbook consiste nell'usare il menu di configurazione.

Eseguire lo script configuration_menu.

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

Diagram that shows the SAP Deployment Automation Ansible configuration menu.

Scegliere i playbook da eseguire.

Playbook: Configurazione del sistema operativo di base

Questo playbook esegue la configurazione generica del sistema operativo in tutti i computer, che include la configurazione di repository software, pacchetti e servizi.

È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                            sap_sid=L00
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"
        "${@}"
)

# 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_01_os_base_config.yaml

Playbook: configurazione del sistema operativo specifica di SAP

Questo playbook esegue l'installazione della configurazione del sistema operativo SAP in tutti i computer. I passaggi includono la creazione di gruppi di volumi e file system e la configurazione di repository software, pacchetti e servizi.

È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                            sap_sid=L00
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"
        "${@}"
)

# 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 SAP Specific Operating System configuration
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_02_os_sap_specific_config.yaml

Playbook: elaborazione DBA

Questo playbook scarica il software SAP nella macchina virtuale SCS.

È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_03_bom_processing.yaml

Playbook: installazione di SCS

Questo playbook installa SAP Central Services. Per le configurazioni a disponibilità elevata, il playbook installa anche l'istanza di SAP ERS e configura Pacemaker.

È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_05_00_00_sap_scs_install.yaml

Playbook: Installazione dell'istanza del database

Questo playbook installa le istanze del database.

È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_04_00_00_db_install.yaml

Playbook: Caricamento del database

Questo playbook richiama l'attività di caricamento del database dal server applicazioni primario.

È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_05_01_sap_dbload.yaml

Playbook: Configurazione della disponibilità elevata del database

Questo playbook configura la disponibilità elevata del database. Per HANA, comporta la replica di sistema HANA e Pacemaker per il database HANA.

È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_04_00_01_db_ha.yaml

Playbook: Installazione del server applicazioni primario

Questo playbook installa il server applicazioni primario. È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_05_02_sap_pas_install.yaml

Playbook: installazioni del server applicazioni

Questo playbook installa i server applicazioni. È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_05_02_sap_app_install.yaml

Playbook: installazioni di Web Dispatcher

Questo playbook installa i Dispatcher Web. È possibile eseguire il playbook usando il menu di configurazione o la riga di comando.

A questo punto è stato distribuito e configurato un sistema HANA autonomo. Se è necessario configurare un database SAP HANA a disponibilità elevata, eseguire il playbook HANA HANA.


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

export                   sap_sid=L00
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 ansible_ssh_pass='{{ lookup("env", "ANSIBLE_PASSWORD") }}'
        --extra-vars="@sap-parameters.yaml"
        "${@}"
)

# 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 download the software from the SAP Library
ansible-playbook "${playbook_options[@]}" ~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_05_04_sap_web_install.yaml

Pulire l'installazione

È importante pulire l'installazione sap da questa esercitazione al termine dell'esercitazione. In caso contrario, si continua a comportare costi correlati alle risorse.

Per rimuovere l'intera infrastruttura SAP distribuita, è necessario:

  • Rimuovere le risorse dell'infrastruttura di sistema SAP.
  • Rimuovere tutte le zone del carico di lavoro (orizzontale).
  • Rimuovere il piano di controllo.

Eseguire la rimozione delle risorse dell'infrastruttura SAP e delle zone del carico di lavoro dalla macchina virtuale di distribuzione. Eseguire la rimozione del piano di controllo da Cloud Shell.

Prima di iniziare, accedere all'account Azure. Verificare quindi di essere nella sottoscrizione corretta.

Rimuovere l'infrastruttura SAP

Passare alla LAB-SECE-SAP01-L00 sottocartella all'interno della SYSTEM cartella . Eseguire quindi questo comando:

export  sap_env_code="LAB"
export   region_code="SECE"
export sap_vnet_code="SAP04"

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/SYSTEM/${sap_env_code}-${region_code}-${sap_vnet_code}-L00

${DEPLOYMENT_REPO_PATH}/deploy/scripts/remover.sh                   \
  --parameterfile "${sap_env_code}-${region_code}-${sap_vnet_code}-L00.tfvars" \
  --type sap_system

Rimuovere l'area del carico di lavoro SAP

Passare alla LAB-XXXX-SAP01-INFRASTRUCTURE sottocartella all'interno della LANDSCAPE cartella . Eseguire poi il comando seguente:


export  sap_env_code="LAB"
export   region_code="SECE"
export sap_vnet_code="SAP01"

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LANDSCAPE/${sap_env_code}-${region_code}-${sap_vnet_code}-INFRASTRUCTURE

${DEPLOYMENT_REPO_PATH}/deploy/scripts/remover.sh                                       \
      --parameterfile ${sap_env_code}-${region_code}-${sap_vnet_code}-INFRASTRUCTURE.tfvars \
      --type sap_landscape

Rimuovere il piano di controllo

Accedere a Cloud Shell.

Passare alla cartella WORKSPACES.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/

Esportare le due variabili di ambiente seguenti:

export DEPLOYMENT_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"
export ARM_SUBSCRIPTION_ID="<subscriptionId>"

Esegui questo comando:

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

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
${DEPLOYMENT_REPO_PATH}/deploy/scripts/remove_controlplane.sh                                                                                                \
    --deployer_parameter_file DEPLOYER/${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE/${env_code}-${region_code}-${vnet_code}-INFRASTRUCTURE.tfvars  \
    --library_parameter_file LIBRARY/${env_code}-${region_code}-SAP_LIBRARY/${env_code}-${region_code}-SAP_LIBRARY.tfvars

Verificare che tutte le risorse siano state pulite.

Passaggio successivo

Configurare il piano di controllo