Tutorial: implantar a Estrutura de Automação de Implantação do SAP para escala empresarial

Artigo
03/19/2024

Este tutorial mostra como executar implantações usando a Estrutura de Automação de Implantação do SAP. Este exemplo usa o Azure Cloud Shell para implantar a infraestrutura do painel de controle. A VM (máquina virtual) do implantador cria a infraestrutura restante e as configurações do SAP HANA.

Neste tutorial, você executa as seguintes tarefas:

Implante o painel de controle (biblioteca e infraestrutura do implantador).
Implante a zona de carga de trabalho (paisagem e sistema).
Baixe/carregue a Lista de materiais.
Defina as configurações do sistema operacional padrão e específico do SAP.
Instale o banco de dados do HANA.
Instale o servidor do SCS (SAP Central Services).
Carregue o banco de dados do HANA.
Instale o servidor de aplicativos primário.

Há três etapas principais de uma implantação do SAP no Azure com a estrutura de automação:

Prepare a região. Você implanta componentes para dar suporte à estrutura de automação do SAP em uma região do Azure especificada. Nesta etapa, você:
1. Crie o ambiente de implantação.
2. Crie um armazenamento compartilhado para arquivos de estado do Terraform.
3. Crie um armazenamento compartilhado para a mídia de instalação do SAP.
Prepare a zona de carga de trabalho. Você implanta os componentes da zona de carga de trabalho, como a rede virtual e cofres de chaves.
Implantar o sistema. Você implanta a infraestrutura para o sistema SAP.

Há vários fluxos de trabalho no processo de automação da implantação. Este tutorial se concentra em um fluxo de trabalho para facilitar a implantação. Você pode implantar esse fluxo de trabalho, o ambiente autônomo do SAP S4 HANA, usando o Bash. Este tutorial descreve a hierarquia geral e as diferentes fases da implantação.

Visão geral do ambiente

A Estrutura de Automação de Implantação do SAP tem dois componentes principais:

Infraestrutura de implantação (plano de controle)
Infraestrutura SAP (carga de trabalho do SAP)

O diagrama abaixo mostra a dependência entre o plano de controle e o plano de aplicativo.

Diagram that shows the DevOps tutorial infrastructure design.

A estrutura usa o Terraform para implantação de infraestrutura e o Ansible para o sistema operacional e a configuração do aplicativo. O diagrama a seguir mostra a separação lógica do plano de controle e da zona de carga de trabalho.

Diagram that shows the SAP Deployment Automation Framework environment.

Zona de gerenciamento

A zona de gerenciamento contém a infraestrutura do painel de controle da qual outros ambientes são implantados. Depois que a zona de gerenciamento é implantada, a necessidade de reimplantação é rara ou até mesmo inexistente.

Diagram that shows the control plane.

O implantador é o mecanismo de execução da estrutura de automação do SAP. Essa VM pré-configurada é usada para executar comandos do Terraform e Ansible.

A Biblioteca SAP fornece o armazenamento persistente dos arquivos de estado do Terraform e a mídia de instalação do SAP baixada para o painel de controle.

Configure o implantador e a biblioteca em um arquivo de variável .tfvars do Terraform. Para obter mais informações, confira Configurar o painel de controle.

Zona de carga de trabalho

Um aplicativo SAP normalmente tem várias camadas de implantação. Por exemplo, você pode ter camadas de desenvolvimento, garantia de qualidade e produção. A Estrutura de Automação de Implantação do SAP chama essas camadas de zonas de carga de trabalho.

Diagram that shows the workload zone.

A zona de carga de trabalho do SAP contém os componentes de rede e compartilhados para as VMs do SAP. Esses componentes incluem tabelas de rotas, grupos de segurança de rede e redes virtuais. A paisagem oferece a oportunidade de dividir implantações em ambientes diferentes. Para obter mais informações, confira Configurar a zona de carga de trabalho.

A implantação do sistema consiste nas VMs para executar o aplicativo SAP, incluindo as camadas da Web, do aplicativo e do banco de dados. Para obter mais informações, confira Configurar o sistema SAP.

Pré-requisitos

O repositório da Estrutura de Automação de Implantação do SAP está disponível no GitHub.

É necessário implantar o Azure Bastion ou usar um cliente SSH (Secure Shell), para se conectar ao implantador. Use qualquer cliente do SSH com o qual você se sinta confortável.

Revisar a cota de assinatura do Azure

Certifique-se de que sua assinatura do Azure tenha uma cotação básica suficiente para SKUs da família DdSV4 e EdsV4 na região eleita. Cerca de 50 núcleos disponíveis para cada família de VM devem ser suficientes.

Conta de usuário S para baixar o software SAP

Uma conta de usuário SAP válida (conta de usuário SAP ou de usuário S) com privilégios de download de software é necessária para baixar o software SAP.

Configurar o Cloud Shell

Vá até o Azure Cloud Shell.
Entre em sua conta do Azure.
```
az login
```
Autentique sua entrada. Não feche a janela até que você seja solicitado.

Valide sua assinatura ativa e registre sua ID da assinatura:

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

Opcionalmente, mude da assinatura ativa.

az account set --subscription <Subscription ID>

Valide se sua assinatura ativa foi alterada.

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

Opcionalmente, remova todos os artefatos de implantação. Use este comando quando quiser remover todos os restos de artefatos de implantação anteriores.
```
cd ~

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

Crie a pasta de implantação e clone o repositório.

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

Opcionalmente, valide as versões do Terraform e a CLI do Azure disponíveis em sua instância do Cloud Shell.
```
./sap-automation/deploy/scripts/helpers/check_workstation.sh
```
Para executar a estrutura de automação, atualize para as versões a seguir:
- az versão 2.5.0 ou posterior.
- terraform versão 1.5 ou superior. Atualize usando as instruções do Terraform, conforme necessário.

Criar uma entidade de serviço

A estrutura de implantação de automação do SAP usa entidades de serviço para implantação. Crie uma entidade de serviço para a implantação do painel de controle. Use uma conta com permissões para criar entidades de serviço.

Quando você escolher um nome para sua entidade de serviço, certifique-se de que o nome seja exclusivo em seu locatário do Azure.

Conceda permissões de Administrador de acesso do usuário e Colaborador à entidade de serviço.

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"

Examine a saída. Por exemplo:

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

Copie os detalhes de saída. Certifique-se de salvar os valores para appId, password, e Tenant.

A saída é mapeada para os parâmetros a seguir. Use esses parâmetros em etapas posteriores, com comandos de automação.

Nome de entrada do parâmetro Nome de saída

spn_id appId

spn_secret password

tenant_id tenant

Nome de entrada do parâmetro	Nome de saída
`spn_id`	`appId`
`spn_secret`	`password`
`tenant_id`	`tenant`

Opcionalmente, atribua a função Administrador de acesso do usuário à entidade de serviço.

export appId="<appId>"

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

Importante

Se você não atribuir a função administrador de acesso do usuário à entidade de serviço, não poderá atribuir permissões usando a automação.

Configurar as credenciais do aplicativo Web do painel de controle

Como parte do painel de controle da estrutura de automação do SAP, você pode criar um aplicativo Web interativo que ajuda a criar os arquivos de configuração necessários.

Screenshot that shows the web app front page.

Criar o Registro do aplicativo

Caso queira usar o aplicativo Web, primeiro precisará criar um registro de aplicativo para fins de autenticação. Abra o Cloud Shell e execute os seguintes comandos:

Substitua LAB pelo ambiente, conforme necessário.

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

Observação

Verifique se você está conectado usando uma conta de usuário que tenha as permissões necessárias para criar registros de aplicativo. Para obter mais informações sobre registros de aplicativo, consulte Criar um registro de aplicativo.

Copie os detalhes de saída. Certifique-se de salvar os valores para App registration ID e App registration password.

A saída é mapeada para os parâmetros a seguir. Use esses parâmetros em etapas posteriores, com comandos de automação.

Nome de entrada do parâmetro	Nome de saída
`app_registration_app_id`	`App registration ID`
`webapp_client_secret`	`App registration password`

Exibir arquivos de configuração

Abra o Visual Studio Code do Cloud Shell.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
code .

Expanda o diretório WORKSPACES. Há seis subpastas: CONFIGURATION, DEPLOYER, LANDSCAPE, LIBRARY, SYSTEM e BOMS. Expanda cada uma dessas pastas para localizar arquivos de configuração de implantação regional.

Localize os arquivos de variáveis da Terraform na subpasta apropriada. Por exemplo, o arquivo de variável Terraform DEPLOYER pode ser semelhante a este exemplo:

# 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

Observe os locais de arquivo de variáveis da Terraform para edições futuras durante a implantação.

Localize os arquivos de variável Terraform para a Biblioteca SAP na subpasta apropriada. Por exemplo, o arquivo de variável Terraform LIBRARY pode ser semelhante a este exemplo:

# 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

Observe os locais de arquivo de variáveis da Terraform para edições futuras durante a implantação.

Importante

Verifique se dns_label corresponde à instância do DNS privado do Azure.

Implantar o painel de controle

Use o script deploy_controlplane.sh para implantar o implantador e a biblioteca. Essas partes da implantação compõem o painel de controle para uma área de automação escolhida.

A implantação passa pelos ciclos de implantação da infraestrutura, atualizando o estado e carregando os arquivos de estado do Terraform para a conta de armazenamento da biblioteca. Todas essas etapas são empacotadas em um único script de implantação. O script precisa do local do arquivo de configuração para o implantador e a biblioteca, e alguns outros parâmetros.

Por exemplo, escolha Oeste da Europa como o local de implantação, com o nome de quatro caracteres SECE conforme descrito anteriormente. O arquivo de configuração LAB-SECE-DEP05-INFRASTRUCTURE.tfvars do implantador de exemplo está na pasta ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/LAB-SECE-DEP05-INFRASTRUCTURE.

O arquivo de configuração LAB-SECE-SAP_LIBRARY.tfvars da Biblioteca SAP de exemplo está na pasta ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/LAB-SECE-SAP_LIBRARY.

Defina as variáveis de ambiente para a entidade de serviço:
```
export ARM_SUBSCRIPTION_ID="<subscriptionId>"
export       ARM_CLIENT_ID="<appId>"
export   ARM_CLIENT_SECRET="<password>"
export       ARM_TENANT_ID="<tenantId>"
```
Se você estiver executando o script de uma estação de trabalho que não faz parte da rede de implantação ou do Cloud Shell, poderá usar o seguinte comando para definir a variável de ambiente para permitir a conectividade do seu endereço IP:
```
export TF_VAR_Agent_IP=<your-public-ip-address>
```
Se você estiver implantando o aplicativo Web de configuração, também precisará definir as seguintes variáveis de ambiente:
```
export TF_VAR_app_registration_app_id=<appRegistrationId>
export    TF_VAR_webapp_client_secret=<appRegistrationPassword>
export                  TF_use_webapp=true
```

Crie o implantador e a Biblioteca SAP e adicione os detalhes da entidade de serviço ao cofre de chaves de implantação usando esse 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 você tiver problemas de autenticação, execute az logout para sair e limpar a token-cache. Em seguida, execute az login para autenticar novamente.

Aguarde até que a estrutura de automação execute as operações do Terraform plan e apply.

A implantação do implantador pode ser executada por cerca de 15 a 20 minutos.

Você precisa anotar alguns valores para as próximas etapas. Procure este bloco de texto na saída:

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

Acesse o portal do Azure.

Selecione Grupos de recursos. Procure os novos grupos de recursos para a infraestrutura e a biblioteca do implantador. Por exemplo, você pode ver LAB-[region]-DEP05-INFRASTRUCTURE e LAB-[region]-SAP_LIBRARY.

O conteúdo do implementador e do grupo de recursos da Biblioteca do SAP é mostrado aqui.

O arquivo de estado do Terraform agora é colocado na conta de armazenamento cujo nome contém tfstate. A conta de armazenamento possui um contêiner chamado tfstate com os arquivos de estado do implantador e da biblioteca. O conteúdo do contêiner tfstate após uma implantação bem-sucedida do plano de controle é mostrado aqui.

Problemas comuns e soluções

Aqui estão algumas dicas para solucionar problemas:

Se você receber o seguinte erro para a criação do módulo do implantador, verifique se está no diretório WORKSPACES ao executar o script:
```
Incorrect parameter file.
The file must contain the environment attribute!!
```
O erro a seguir é transitório. Execute novamente o mesmo comando, deploy_controlplane.sh.
```
Error: file provisioner error
..
timeout - last error: dial tcp
```
Se você tiver problemas de autenticação diretamente depois de executar o script deploy_controlplane.sh, execute este comando:
```
az logout

az login
```

Conectar-se à VM do implantador

Depois que o painel de controle é implantado, o estado do Terraform é armazenado usando o back-end remoto azurerm. Todos os segredos para se conectar à VM do implantador estão disponíveis em um cofre de chaves no grupo de recursos do implantador.

Para conectar-se à VM do implementador:

Entre no portal do Azure.
Selecione ou pesquise cofres de chaves.
Na página Cofre de chaves, localize o cofre de chaves do implantador. O nome começa com LAB[REGION]DEP05user. Filtrar por Grupo de recursos ou Local, se necessário.
Na seção Configurações no painel esquerdo, selecione Segredos.
Localize e selecione o segredo que contém sshkey. Pode se parecer com LAB-[REGION]-DEP05-sshkey.
Na página do segredo, selecione a versão atual. Em seguida, copie o valor do segredo.
Abra um editor de texto sem formatação. Copie no valor secreto.
Salve o arquivo no local onde você mantém as chaves SSH. Por exemplo, use C:\\Users\\<your-username>\\.ssh.
Salve o arquivo. Se você for solicitado a Salvar como tipo, selecione Todos os arquivos se o SSH não for uma opção. Por exemplo, use deployer.ssh.
Conecte-se à VM do implementador por meio de qualquer cliente SSH, como o Visual Studio Code. Use o endereço IP público que você anotou anteriormente e a chave SSH baixada. Para obter instruções sobre como se conectar ao implantador usando Visual Studio Code, confira Conectar-se ao implantador usando Visual Studio Code. Se você estiver usando o PuTTY, converta o arquivo de chave SSH primeiro usando PuTTYGen.

Observação

O nome de usuário padrão é azureadm.

Verifique se o arquivo usado para salvar a chave SSH pode salvar o arquivo usando o formato correto, ou seja, sem caracteres CR (retorno de carro). Use o Visual Studio Code ou Bloco de notas++.

Depois de se conectar à VM do implementador, você poderá baixar o software SAP usando a lista de materiais (BOM).

Conecte-se à VM do implementador quando não estiver usando um IP público

Para implantações sem conectividade IP pública, a conectividade direta pela Internet não é permitida. Nesses casos, use uma caixa de salto do Azure Bastion ou execute a próxima etapa de um computador que tenha conectividade com a rede virtual do Azure.

O exemplo a seguir usa o Azure Bastion.

Para se conectar ao implantador:

Entre no portal do Azure.
Vá para o grupo de recursos que contém a VM do implementador.
Conecte-se à VM usando o Azure Bastion.
O nome de usuário padrão é azureadm.
Selecione chave privada SSH no Azure Key Vault.
Selecione a assinatura que contém o painel de controle.
Selecione o cofre de chaves do implantador.
Na lista de segredos, selecione o segredo que termina com -sshkey.
Conectar-se à VM.

O restante das tarefas deve ser executado no implantador.

Proteja o painel de controle

O plano de controle é a parte mais crítica da estrutura de automação SAP. É importante proteger o plano de controle. As etapas a seguir ajudam você a proteger o plano de controle.

Atualize o arquivo tfvars do plano de controle para habilitar pontos de extremidade privados e bloquear o acesso público às contas de armazenamento e aos cofres de chaves.

Para copiar os arquivos de configuração do plano de controle para a VM do implantador, você pode usar o script sync_deployer.sh. Entre na VM do implantador e atualize o comando a seguir para usar o nome da conta de armazenamento de estado do Terraform. Em seguida, execute o script a seguir:
```
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
```
Este comando copia os arquivos de configuração tfvars da conta de armazenamento da Biblioteca SAP para a VM do implantador.

Altere os arquivos de configuração do plano de controle para:


    # 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

Execute novamente a implantação para aplicar as alterações. Atualize o nome da conta de armazenamento e o nome do cofre de chaves no script.


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

Crie o implantador e a Biblioteca 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}"

Implantar o aplicativo Web

Você pode implantar o aplicativo Web usando o seguinte script:

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

Coletar informações da zona de carga de trabalho

Colete as seguintes informações em um editor de texto. Essas informações foram coletadas no final da fase "Implantar o painel de controle".
1. O nome da conta de armazenamento de arquivos de estado Terraform no grupo de recursos da biblioteca:
  - Seguindo o exemplo anterior, o grupo de recursos é LAB-SECE-SAP_LIBRARY.
  - O nome da conta de armazenamento contém labsecetfstate.
2. O nome do cofre de chaves no grupo de recursos do implantador:
  - Seguindo o exemplo anterior, o grupo de recursos é LAB-SECE-DEP05-INFRASTRUCTURE.
  - O nome do cofre de chaves contém LABSECEDEP05user.
3. O endereço IP público da VM do implantador. Vá para o grupo de recursos do implantador, abra a VM do implantador e copie o endereço IP público.
Você precisa coletar as seguintes informações:
1. O nome do arquivo de estado do implantador é encontrado no grupo de recursos da biblioteca:
  - Selecione Grupo de recursos de biblioteca>Conta de armazenamento de estado>Contêineres>tfstate. Copie o nome do arquivo de estado do implantador.
  - Seguindo o exemplo anterior, o nome do blob é LAB-SECE-DEP05-INFRASTRUCTURE.terraform.tfstate.

Se necessário, registre a entidade de serviço. Para este tutorial, essa etapa não é necessária.

Na primeira vez que uma instância de um ambiente é criada, uma entidade de serviço deve ser registrada. Neste tutorial, o painel de controle está no ambiente LAB, e a zona de carga de trabalho está em LAB. Por esse motivo, uma entidade de serviço deve ser registrada para o 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}"

Preparar a implantação da zona de carga de trabalho

Conecte à VM do implantador para as etapas a seguir. Agora, uma cópia do repositório está lá.

Implantar a zona de carga de trabalho

Use o script install_workloadzone para implantar a zona de carga de trabalho SAP.

Na VM do implementador, vá para a pasta Azure_SAP_Automated_Deployment.

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

Opcionalmente, abra o arquivo de configuração da zona de carga de trabalho e, se necessário, altere o nome lógico da rede para corresponder ao nome da rede.
Inicie a implantação da zona de carga de trabalho. Os detalhes que você coletou anteriormente são necessários aqui:
- Nome do arquivo tfstate do implementador (encontrado no contêiner tfstate)
- Nome da conta de armazenamento tfstate
- Nome do cofre de chaves do implantador


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

A implantação da zona de carga de trabalho deve ser iniciada automaticamente.

Aguarde até que a implantação seja concluída. O novo grupo de recursos aparece na portal do Azure.

Preparar para implantar a infraestrutura do sistema SAP

Conecte à VM do implantador para as etapas a seguir. Agora, uma cópia do repositório está lá.

Vá para a pasta WORKSPACES/SYSTEM e copie os arquivos de configuração de amostra para usar do repositório.

Implantar a infraestrutura do sistema SAP

Após a conclusão da zona de carga de trabalho, você pode implantar os recursos de infraestrutura do sistema SAP. O sistema SAP cria suas VMs e componentes de suporte para seu aplicativo SAP. Use o script installer.sh para implantar o sistema SAP.

O sistema SAP implanta:

A camada de banco de dados, que implanta VMs de banco de dados, seus discos e uma instância do Azure Standard Load Balancer. Você pode executar bancos de dados do HANA ou bancos de dados AnyDB nessa camada.
A camada SCS, que implanta um número definido pelo cliente de VMs e uma instância do Azure Standard Load Balancer.
A camada de aplicativo, que implanta as VMs e seus discos.
A camada do Dispatcher da Web.

Implante o 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

Verifique se o grupo de recursos do sistema está agora na portal do Azure.

Obtenha o software SAP usando a Lista de materiais

A estrutura de automação oferece ferramentas para baixar software do SAP usando a BOM do SAP. O software é baixado na Biblioteca SAP, que atua como a camada de arquivos de todas as mídias necessárias para implantar o SAP.

A marca de ordem de byte (BOM) do SAP imita o planejador de manutenção SAP. Há identificadores de produto relevantes e um conjunto de URLs de download.

Um extrato de amostra de um arquivo BOM se parece com este exemplo:


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

Para esta configuração de exemplo, o grupo de recursos é LAB-SECE-DEP05-INFRASTRUCTURE. O nome do key vault do implantador contém LABSECEDEP05user no nome. Use essas informações para configurar os segredos do cofre de chaves do implantador.

Conecte à VM do implantador para as etapas a seguir. Agora, uma cópia do repositório está lá.
Adicione um segredo com o nome de usuário da sua conta do SAP. Substitua <vaultName> pelo nome do cofre de chaves do implantador. Substitua também <sap-username> pelo nome de usuário do SAP.
```
export key_vault=<vaultName>
    sap_username=<sap-username>

az keyvault secret set --name "S-Username" --vault-name $key_vault --value "${sap_username}";
```
Adicione um segredo com a senha da sua conta do SAP. Substitua <vaultName> pelo nome do cofre de chaves do implantador e substitua <sap-password> pela sua senha do SAP.

Observação

O uso de aspas simples quando você define sap_user_password é importante. O uso de caracteres especiais na senha pode, de outra forma, causar resultados imprevisíveis.
```
sap_user_password='<sap-password>'

az keyvault secret set --name "S-Password" --vault-name "${key_vault}" --value="${sap_user_password}";
```
Configure seu arquivo de parâmetros do SAP para o processo de download. Em seguida, baixe o software do SAP usando os guias estratégicos do Ansible. Execute os comandos a seguir:
```
cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
mkdir BOMS
cd BOMS

vi sap-parameters.yaml
```
Atualize o bom_base_name com o nome BOM. Substitua <Deployer KeyVault Name> pelo nome do Azure Key Vault para o grupo de recursos do implantador.

Seu arquivo deve ser semelhante à seguinte configuração de exemplo:
```
bom_base_name:                 S42022SPS00_v0001ms
deployer_kv_name:              <vaultName>
BOM_directory:                 ${HOME}/Azure_SAP_Automated_Deployment/samples/SAP
```
Execute o guia estratégico do Ansible para baixar o software. Uma maneira de executar os playbooks é usar o menu Ferramenta de download. Execute o script download_menu.
```
${HOME}/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/download_menu.sh
```

Selecione quais playbooks serão executados.

1) BoM Downloader
3) Quit
Please select playbook:

Selecione o guia estratégico 1) BoM Downloader para baixar o software SAP descrito no arquivo da BOM na conta de armazenamento. Verifique se o contêiner sapbits tem toda a sua mídia para instalação.

Execute o guia estratégico usando o menu de configuração ou diretamente da linha de 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

Caso queira, também poderá passar as credenciais do usuário SAP como parâmetros.


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

Instalação do aplicativo SAP

A instalação do aplicativo SAP ocorre através de guias estratégicos do Ansible.

Vá para a pasta de implantação do sistema.

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

Certifique-se de ter os seguintes arquivos nas pastas atuais: sap-parameters.yaml e L00_host.yaml.

Para um sistema SAP S/4HANA autônomo, há oito playbooks para executar em sequência. Uma maneira de executar os guias estratégicos é usar o menu Configuração.

Execute o script configuration_menu.

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

Escolha os guias estratégicos a serem executados.

Guia estratégico: configuração do sistema operacional base

Este guia estratégico faz a configuração genérica do sistema operacional em todos os computadores, o que inclui a configuração de repositórios de software, pacotes e serviços.