Introduzione alla distribuzione manuale

Articolo
10/27/2023

Oltre alla distribuzione automatizzata, è anche possibile eseguire la distribuzione manuale di SAP in Azure Deployment Automation Framework. Usare questa configurazione di esempio e i file di parametri di esempio per iniziare.

Suggerimento

Questa guida illustra solo come eseguire una distribuzione manuale . Per iniziare rapidamente, vedere invece la guida alla distribuzione automatizzata.

Questi passaggi fanno riferimento e usano la convenzione di denominazione predefinita per il framework di automazione. I valori di esempio vengono usati anche per la denominazione in tutto il codice. Ad esempio, il nome del deployer è DEMO-EUS2-DEP00-INFRASTRUCTURE. In questo esempio l'ambiente è una demo (DEMO), l'area è Stati Uniti orientali 2 (EUS2) e la rete virtuale del deployer è DEP00.

Prerequisiti

Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, è possibile creare un account gratuito.
Un account Azure con privilegi per creare un'entità servizio.
Download del software SAP nell'ambiente Azure.

Configurazione di Deployer

Prima di iniziare, verificare di essere nella sottoscrizione di Azure corretta. Configurare quindi il deployer:

Scaricare e installare Terraform.
Clonare e configurare il repository del framework di automazione nel deployer.
Inizializzare Terraform
Ottenere le chiavi SSH da usare nel resto della distribuzione.

Controllare la sottoscrizione di Azure

Verificare di usare la sottoscrizione di Azure appropriata:

Accedi al portale di Azure.
Aprire Azure Cloud Shell.
Verificare di essere nella sottoscrizione che si vuole usare:
```
az account list --output=table | grep -i true
```
Se necessario, modificare la sottoscrizione attiva con la sottoscrizione che si vuole usare.

Scaricare Terraform

Scaricare Terraform nell'ambiente:

Creare e passare a una nuova directory, bin.
```
mkdir -p ~/bin; cd $_
```

Recuperare il file binario Terraform appropriato. Ad esempio:

wget  https://releases.hashicorp.com/terraform/0.14.7/terraform_0.14.7_linux_amd64.zip

Decomprimere il file binario Terraform. Ad esempio:
```
unzip terraform_0.14.7_linux_amd64.zip
```
Verificare il download di Terraform:
```
hash terraform
```
Creare una directory per la distribuzione automatica di SAP.
```
mkdir -p ~/Azure_SAP_Automated_Deployment; cd $_
```

Configurare il repository

Clonare e configurare il repository del framework di automazione.

Clonare il repository da GitHub:

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

Passa alla cartella sap-automation.

cd  ~/Azure_SAP_Automated_Deployment/sap-automation

Facoltativamente, controllare un ramo diverso rispetto al ramo principale. Il ramo principale per il repository è l'impostazione predefinita.
1. Sostituire <branch> con il nome del ramo o l'hash di commit che si vuole usare.
```
git checkout <branch>
```
2. Verificare che il ramo sia in corrispondenza della revisione prevista.
```
git rev-parse HEAD
```

Inizializzare Terraform

Creare una directory di lavoro. Il nome della directory deve rispettare la convenzione di denominazione predefinita. Ad esempio:
```
mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/DEMO-EUS2-DEP00-INFRASTRUCTURE; cd $_
```

Creare il file di parametri JSON.

cat <<EOF > DEMO-EUS2-DEP00-INFRASTRUCTURE.json
{
  "infrastructure": {
    "environment"                         : "DEMO",
    "region"                              : "eastus2",
    "vnets": {
      "management": {
        "name"                            : "DEP00",
        "address_space"                   : "10.0.0.0/25",
        "subnet_mgmt": {
          "prefix"                        : "10.0.0.64/28"
        },
        "subnet_fw": {
          "prefix"                        : "10.0.0.0/26"
        }
      }
    }
  },
  "options": {
    "enable_deployer_public_ip"           : true
  },
  "firewall_deployment"                   : true
}
EOF

Inizializzare Terraform.

terraform init  ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/

Creare un piano di esecuzione terraform che segue la convenzione di denominazione predefinita.

terraform plan                                                                    \
                --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                    \
                ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/

Applicare il piano di esecuzione di Terraform per distribuire le risorse.

terraform apply --auto-approve                                                    \
                --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                    \
                ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/

Prendere nota dell'output.

Ottenere chiavi SSH

Usando l'output della distribuzione di Terraform, prendere nota dei valori per i campi seguenti.
1. Indirizzo IP pubblico: deployer_public_ip_address.
2. Nome utente dell'insieme di credenziali delle chiavi: deployer_kv_user_name.
3. Nome dell'insieme di credenziali delle chiavi private: deployer_kv_prvt_name.
4. Nome della chiave pubblica: deployer_public_key_secret_name.
5. Nome della chiave privata: deployer_private_key_secret_name.
Eseguire lo script di post-elaborazione.
```
./post_deployment.sh
```

Estrarre la chiave SSH privata:

az keyvault secret show               \
  --vault-name DEMOEUS2DEP00userE27   \
  --name DEMO-EUS2-DEP00-sshkey     | \
  jq -r .value > sshkey

Estrarre la chiave SSH pubblica:

az keyvault secret show               \
  --vault-name DEMOEUS2DEP00userF6A   \
  --name DEMO-EUS2-DEP00-sshkey-pub | \
  jq -r .value > sshkey.pub

Scaricare la coppia di chiavi private e pubbliche. Nel menu di Cloud Shell selezionare Carica/Scarica file>.

Configurazione dell'entità servizio

Il deployer usa un'entità servizio per distribuire le risorse in una sottoscrizione.

Accedere all'interfaccia della riga di comando di Azure.
```
az login
```
Creare un'entità servizio. Assicurarsi di sostituire <subscription-id> con l'identificatore della sottoscrizione di Azure. Sostituire <sp-name> anche con un nome per l'entità servizio.
```
az ad sp create-for-rbac --role="Contributor" --scopes="/subscriptions/<subscription-id>" --name="<sp-name>"
```
Si noti l'output, che contiene informazioni sull'entità servizio. Copiare i valori dei campi seguenti:
1. Identificatore dell'applicazione: appId.
2. Password: password.
3. Identificatore del tenant: tenant.
Creare un'assegnazione di ruolo per l'entità servizio. Assicurarsi di sostituire <appId> con l'identificatore dell'applicazione annotato nel passaggio precedente.
```
az role assignment create --assignee <appId> --role "User Access Administrator" --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group-name>
```

Aggiungere chiavi per l'entità servizio all'insieme di credenziali delle chiavi come indicato di seguito. Assicurarsi di sostituire i valori segnaposto con le informazioni annotate nei passaggi precedenti. Sostituire <environment> con il nome dell'ambiente, ad esempio DEMO.

az keyvault secret set --name "<environment>-subscription-id" --vault-name "<deployer_kv_user_name>" --value "<subscription-id>";
az keyvault secret set --name "<environment>-tenant-id"       --vault-name "<deployer_kv_user_name>" --value "<tenant>";
az keyvault secret set --name "<environment>-client-id"       --vault-name "<deployer_kv_user_name>" --value "<appId>";
az keyvault secret set --name "<environment>-client-secret"   --vault-name "<deployer_kv_user_name>" --value "<password>";

Configurazione della libreria

Accedere al deployer usando il client SSH e le chiavi SSH recuperate durante l'installazione del deployer. Se si usa PuTTY come client SSH, convertire le chiavi SSH in .ppk formato prima di usare.
Passare alla posizione in cui è stato clonato il repository del framework di automazione.
```
cd  ~/Azure_SAP_Automated_Deployment/sap-automation
```
Facoltativamente, controllare un ramo diverso rispetto al ramo principale. Il ramo principale per il repository è l'impostazione predefinita.
1. Sostituire <branch> con il nome del ramo o l'hash di commit che si vuole usare.
```
git checkout <branch>
```
2. Verificare che il ramo sia in corrispondenza della revisione prevista.
```
git rev-parse HEAD
```

Creare una directory di lavoro.

mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/DEMO-EUS2-SAP_LIBRARY; cd $_

Creare il file di configurazione JSON.

cat <<EOF > DEMO-EUS2-SAP_LIBRARY.json
{
  "infrastructure": {
    "environment"                         : "DEMO",
    "region"                              : "eastus2"
  },
  "deployer": {
    "environment"                         : "DEMO",
    "region"                              : "eastus2",
    "vnet"                                : "DEP00"
  }
}
EOF

Inizializzare Terraform.

terraform init  ../../../sap-automation/deploy/terraform/bootstrap/sap_library/

Creare un piano di esecuzione terraform che segue la convenzione di denominazione predefinita.

terraform plan                                                                  \
            --var-file=DEMO-EUS2-SAP_LIBRARY.json                           \
            ../../../sap-automation/deploy/terraform/bootstrap/sap_library

Applicare il piano di esecuzione di Terraform per distribuire le risorse.

terraform apply --auto-approve                                                  \
            --var-file=DEMO-EUS2-SAP_LIBRARY.json                           \
            ../../../sap-automation/deploy/terraform/bootstrap/sap_library/

Reinizializzare la distribuzione

Reinizializzare sia il deployer che la libreria SAP.

Reinizializzare il deployer

Rimanere connessi al server di distribuzione nel client SSH. In alternativa, accedere di nuovo.

Passare alla directory di lavoro creata.

cd ~/Azure_SAP_Automated_Deployment/WORKSPACES/LOCAL/DEMO-EUS2-DEP00-INFRASTRUCTURE

Creare un altro file di parametri denominato backend. Anche in questo caso, seguire le convenzioni di denominazione predefinite. Per resource_group_nameusare il nome del gruppo di risorse in cui si trova l'account di archiviazione con i file di stato terraform (.tfstate). Per storage_account_namesostituire <tfstate_storage_account_name> con il nome dell'account di archiviazione dalla distribuzione della libreria SAP per .tfstate i file. Per key, combinare il nome del gruppo di risorse del deployer con l'estensione .terraform.tfstate. Ad esempio:
```
cat <<EOF > backend
resource_group_name   = "DEMO-EUS2-SAP_LIBRARY"
storage_account_name  = "<tfstate_storage_account_name>"
container_name        = "tfstate"
key                   = "DEMO-EUS2-DEP00-INFRASTRUCTURE.terraform.tfstate"
EOF
```

Inizializzare di nuovo Terraform.

terraform init  --backend-config backend                                        \
                ../../../sap-automation/deploy/terraform/run/sap_deployer/

Quando viene richiesto , copiare lo stato esistente nel nuovo back-end? immettere yes.
Rimuovere il file di stato locale.
```
rm terraform.tfstate*
```

Creare un piano di esecuzione di Terraform. Anche in questo caso, seguire le convenzioni di denominazione predefinite. Ad esempio:

terraform plan                                                                  \
                --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                  \
                ../../../sap-automation/deploy/terraform/run/sap_deployer/

Applicare il piano di esecuzione terraform. Ad esempio:

terraform apply --auto-approve                                                  \
                --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                  \
                ../../../sap-automation/deploy/terraform/run/sap_deployer/

Reinizializzare la libreria SAP

Rimanere connessi al server di distribuzione nel client SSH. In alternativa, accedere di nuovo.

Passare alla directory di lavoro creata.

cd ~/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/DEMO-EUS2-SAP_LIBRARY

Creare un altro file di parametri denominato backend. Anche in questo caso, seguire le convenzioni di denominazione predefinite. Per resource_group_nameusare il nome del gruppo di risorse in cui si trova l'account di archiviazione con i file di stato terraform (.tfstate). Per storage_account_namesostituire <tfstate_storage_account_name> con il nome dell'account di archiviazione dalla distribuzione della libreria SAP per .tfstate i file. Per key, combinare il nome del gruppo di risorse del deployer con l'estensione .terraform.tfstate. Ad esempio:
```
cat <<EOF > backend
resource_group_name   = "DEMO-EUS2-SAP_LIBRARY"
storage_account_name  = "<tfstate_storage_account_name>"
container_name        = "tfstate"
key                   = "DEMO-EUS2-SAP_LIBRARY.terraform.tfstate"
EOF
```
Aggiungere una nuova coppia chiave-valore subito dopo la parentesi aperta ({) del file backenddi parametri . Per tfstate_resource_idusare l'identificatore della risorsa per l'account di archiviazione dei file di stato Terraform. Per deployer_tfstate_keyusare il nome della chiave per il file di stato del deployer. Ad esempio:
```
{
    "tfstate_resource_id"                   : "<identifier>",
    "deployer_tfstate_key"                  : "<key>",
    "infrastructure": {
        ...
}
```

Inizializzare di nuovo Terraform.

terraform init  --backend-config backend                                          \
                ../../../sap-automation/deploy/terraform/run/sap_library/

Quando viene richiesto , copiare lo stato esistente nel nuovo back-end? immettere yes.
Rimuovere il file di stato locale.
```
rm terraform.tfstate*
```

Creare un piano di esecuzione di Terraform. Anche in questo caso, seguire le convenzioni di denominazione predefinite. Ad esempio:

terraform plan                                                                    \
                --var-file=DEMO-EUS2-SAP_LIBRARY.json                             \
                ../../../sap-automation/deploy/terraform/run/sap_library/

Applicare il piano di esecuzione terraform. Ad esempio:

terraform apply --auto-approve                                                    \
                --var-file=DEMO-EUS2-SAP_LIBRARY.json                             \
                ../../../sap-automation/deploy/terraform/run/sap_library/

Distribuire la rete virtuale del carico di lavoro

Distribuire quindi la rete virtuale del carico di lavoro SAP.

Rimanere connessi al server di distribuzione nel client SSH. In alternativa, accedere di nuovo.

Creare una directory di lavoro. Seguire le convenzioni di denominazione predefinite.

mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/LANDSCAPE/DEMO-EUS2-SAP00-INFRASTRUCTURE; cd $_

Creare un file di parametri denominato backend. Per resource_group_nameusare il nome del gruppo di risorse in cui si trova l'account di archiviazione con i file di stato terraform (.tfstate). Per storage_account_namesostituire <tfstate_storage_account_name> con il nome dell'account di archiviazione dalla distribuzione della libreria SAP per .tfstate i file. Per key, combinare il nome del gruppo di risorse del deployer con l'estensione .terraform.tfstate. Ad esempio:
```
cat <<EOF > backend
resource_group_name   = "DEMO-EUS2-SAP_LIBRARY"
storage_account_name  = "<tfstate_storage_account_name>"
container_name        = "tfstate"
key                   = "DEMO-EUS2-SAP00-INFRASTRUCTURE.terraform.tfstate"
EOF
```

Inizializzare di nuovo Terraform.

terraform init  --backend-config backend                                        \
                ../../../sap-automation/deploy/terraform/run/sap_landscape/

Creare un piano di esecuzione di Terraform. Anche in questo caso, seguire le convenzioni di denominazione predefinite. Ad esempio:

terraform plan                                                                  \
            --var-file=DEMO-EUS2-SAP00-INFRASTRUCTURE.json                  \
            ../../../sap-automation/deploy/terraform/run/sap_landscape/

Applicare il piano di esecuzione terraform. Ad esempio:

terraform apply --auto-approve                                                  \
                --var-file=DEMO-EUS2-SAP00-INFRASTRUCTURE.json                  \
                ../../../sap-automation/deploy/terraform/run/sap_landscape/

Unità di distribuzione SAP

Configurare quindi l'unità di distribuzione SAP.

Rimanere connessi al server di distribuzione nel client SSH. In alternativa, accedere di nuovo

Creare una directory di lavoro. Seguire le convenzioni di denominazione predefinite.

mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/SYSTEM/DEMO-EUS2-SAP00-X00; cd $_

Creare un altro file di parametri denominato backend. Per resource_group_nameusare il nome del gruppo di risorse in cui si trova l'account di archiviazione con i file di stato terraform (.tfstate). Per storage_account_namesostituire <tfstate_storage_account_name> con il nome dell'account di archiviazione dalla distribuzione della libreria SAP per .tfstate i file. Per key, combinare il nome del gruppo di risorse del deployer con l'estensione .terraform.tfstate. Ad esempio:
```
cat <<EOF > backend
resource_group_name   = "DEMO-EUS2-SAP_LIBRARY"
storage_account_name  = "<tfstate_storage_account_name>"
container_name        = "tfstate"
key                   = "DEMO-EUS2-SAP00-X00.terraform.tfstate"
EOF
```

Creare un file di parametri JSON con parametri di input come indicato di seguito. Assicurarsi di sostituire i valori di esempio con i propri.

cat <<EOF > DEMO-EUS2-SAP00-X00.json
{
  "tfstate_resource_id"                   : "<resource-id>",
  "deployer_tfstate_key"                  : "DEMO-EUS2-DEP00-INFRASTRUCTURE.terraform.tfstate",
  "landscape_tfstate_key"                 : "DEMO-EUS2-SAP00-INFRASTRUCTURE.terraform.tfstate",
  "infrastructure": {
    "environment"                         : "DEMO",
    "region"                              : "eastus2",
    "vnets": {
      "sap": {
        "name"                            : "SAP00",
        "subnet_db": {
          "prefix"                        : "0.0.0.0/28"
        },
        "subnet_web": {
          "prefix"                        : "0.0.0.0/28"
        },
        "subnet_app": {
          "prefix"                        : "0.0.0.0/27"
        },
        "subnet_admin": {
          "prefix"                        : "0.0.0.0/27"
        }
      }
    }
  },
  "databases": [
    {
      "platform"                          : "HANA",
      "high_availability"                 : false,
      "size"                              : "S4Demo",
      "os": {
        "publisher"                       : "SUSE",
        "offer"                           : "sles-sap-12-sp5",
        "sku"                             : "gen2",
        "version"                         : "latest"
      }
    }
  ],
  "application": {
    "enable_deployment"                   : true,
    "sid"                                 : "X00",
    "scs_instance_number"                 : "00",
    "ers_instance_number"                 : "10",
    "scs_high_availability"               : false,
    "application_server_count"            : 3,
    "webdispatcher_count"                 : 1,
    "authentication": {
      "type"                              : "key",
      "username"                          : "azureadm"
    }
  }
}
EOF

Inizializzare di nuovo Terraform.

terraform init  --backend-config backend                                        \
                ../../../sap-automation/deploy/terraform/run/sap_system/

Creare un piano di esecuzione di Terraform. Anche in questo caso, seguire le convenzioni di denominazione predefinite. Ad esempio:

terraform plan                                                                  \
                --var-file=DEMO-EUS2-SAP00-X00.json                             \
                ../../../sap-automation/deploy/terraform/run/sap_system/

Applicare il piano di esecuzione terraform. Ad esempio:

terraform apply --auto-approve                                                  \
                --var-file=DEMO-EUS2-SAP00-X00.json                             \
                ../../../sap-automation/deploy/terraform/run/sap_system/

Configurazione di Ansible

Configurare l'installazione eseguendo playbook ansible. Questi playbook si trovano nel repository del framework di automazione in /sap-automation/deploy/ansible.

Filename	Descrizione
`playbook_01_os_base_config.yaml`	Configurazione del sistema operativo di base
`playbook_02_os_sap_specific_config.yaml`	Configurazione del sistema operativo specifica di SAP
`playbook_03_bom_processing.yaml`	Download del software di elaborazione della distinta base (BOM) di SAP
`playbook_04a_sap_scs_install.yaml`	Installazione di SAP Central Services (SCS)
`playbook_05a_hana_db_install.yaml`	Installazione del database SAP HANA
`playbook_06a_sap_dbload.yaml`	Caricatore di database
`playbook_06b_sap_pas_install.yaml`	Installazione del server applicazioni primario SAP (PAS)
`playbook_06c_sap_app_install.yaml`	Installazione del server applicazioni SAP
`playbook_06d_sap_web_install.yaml`	Installazione del dispatcher Web SAP
`playbook_06_00_00_pacemaker.yaml`	Configurazione del cluster Pacemaker
`playbook_06_00_01_pacemaker_scs.yaml`	Configurazione pacemaker per SCS
`playbook_06_00_03_pacemaker_hana.yaml`	Configurazione pacemaker per il database SAP HANA

Per eseguire un playbook o più playbook, usare il comando ansible-playbook come indicato di seguito. Assicurarsi di modificare tutti i valori segnaposto in base alle proprie informazioni:

Passare <your-sapbits-path> al percorso dell'account sapbits di archiviazione per la libreria SAP.
Passare <azure-admin> al nome utente dell'amministratore di Azure.
Passare <ssh-key> alla chiave SSH privata da usare.
Modificare altri valori in --extra-vars in base alle esigenze per le impostazioni.

In caso di problemi, assicurarsi di aver scaricato il software SAP nell'ambiente Azure.

export           ANSIBLE_HOST_KEY_CHECKING=False
# export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=Yes
# export           ANSIBLE_KEEP_REMOTE_FILES=1


ansible-playbook                                                                                                      \
  --inventory   new-hosts.yaml                                                                                        \
  --user        <azure-admin>                                                                                              \
  --private-key <ssh-key>                                                                                                \
  --extra-vars="{                                                                                                     \
                  \"bom_base_name\":                \"HANA_2_00_053_v001\",                                           \
                  \"download_templates\":           \"false\",                                                        \
                  \"sapbits_location_base_path\":   \"<your-sapbits-path>",        \
                  \"target_media_location\":        \"/usr/sap/install\",                                             \
                  \"sap_sid\":                      \"X00\",                                                          \
                  \"hdb_sid\":                      \"HDB\"                                                           \
                }"                                                                                                    \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_00_transition_start_for_sap_install_refactor.yaml     \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_01_os_base_config.yaml                       \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_02_os_sap_specific_config.yaml               \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_03_bom_processing.yaml                       \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_04a_sap_scs_install.yaml                     \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_05a_hana_db_install.yaml                     \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_06a_sap_dbload.yaml                          \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_06b_sap_pas_install.yaml                     \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_06c_sap_app_install.yaml                     \
~/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/playbook_06d_sap_web_install.yaml

Passaggi successivi

Iniziare rapidamente a usare una distribuzione automatizzata

Condividi tramite

Introduzione alla distribuzione manuale

Prerequisiti

Configurazione di Deployer

Controllare la sottoscrizione di Azure

Scaricare Terraform

Configurare il repository

Inizializzare Terraform

Ottenere chiavi SSH

Configurazione dell'entità servizio

Configurazione della libreria

Reinizializzare la distribuzione

Reinizializzare il deployer

Reinizializzare la libreria SAP

Distribuire la rete virtuale del carico di lavoro

Unità di distribuzione SAP

Configurazione di Ansible

Passaggi successivi

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive