Tutorial: Implantar o SAP Deployment Automation Framework para escala empresarial

Artigo
03/13/2024

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

Neste tutorial, vai realizar as seguintes tarefas:

Implante o plano de controle (infraestrutura e biblioteca do implantador).
Implante a zona de carga de trabalho (paisagem e sistema).
Download/upload da lista de materiais.
Configure as configurações padrão e específicas do sistema operacional SAP.
Instale o banco de dados HANA.
Instale o servidor SAP Central Services (SCS).
Carregue o banco de dados HANA.
Instale o servidor de aplicativos primário.

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

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

Há vários fluxos de trabalho no processo de automação de 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 SAP S4 HANA, usando o Bash. Este tutorial descreve a hierarquia geral e as diferentes fases da implantação.

Visão geral do ambiente

O SAP Deployment Automation Framework tem dois componentes principais:

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

O diagrama a seguir 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 Terraform para implantação de infraestrutura e Ansible para o sistema operacional e configuração de aplicativos. 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 gestão

A zona de gerenciamento contém a infraestrutura do plano de controle a partir da qual outros ambientes são implantados. Depois que a zona de gerenciamento é implantada, você raramente, ou nunca, precisa reimplantar.

Diagram that shows the control plane.

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

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

Você configura o implantador e a biblioteca em um arquivo variável Terraform .tfvars . Para obter mais informações, consulte Configurar o plano de controle.

Zona de carga de trabalho

Um aplicativo SAP normalmente tem várias camadas de implantação. Por exemplo, você pode ter níveis de desenvolvimento, garantia de qualidade e produção. O SAP Deployment Automation Framework chama essas camadas de zonas de carga de trabalho.

Diagram that shows the workload zone.

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

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

Pré-requisitos

O repositório do SAP Deployment Automation Framework está disponível no GitHub.

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

Rever a quota de subscrição do Azure

Certifique-se de que sua assinatura do Azure tenha uma cotação principal 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 VMs devem ser suficientes.

Conta S-User para download do software SAP

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

Configurar o Cloud Shell

Aceda ao Azure Cloud Shell.
Inicie sessão na sua conta do Azure.
```
az login
```
Autentique o seu início de sessão. Não feche a janela até ser solicitado.

Valide a sua subscrição ativa e registe o seu ID de subscrição:

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

Se necessário, altere a sua subscrição ativa.

az account set --subscription <Subscription ID>

Valide se a sua subscrição 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 da 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 seguintes versões:
- az versão 2.5.0 ou superior.
- terraform versão 1.5 ou superior. Atualize usando as instruções Terraform, conforme necessário.

Criar um principal de serviço

A estrutura de implantação de automação SAP usa entidades de serviço para implantação. Crie uma entidade de serviço para a implantação do plano de controle. Certifique-se de usar uma conta com permissões para criar entidades de serviço.

Ao escolher um nome para sua entidade de serviço, verifique se o nome é exclusivo em seu locatário do Azure.

Conceda à entidade de serviço permissões de Colaborador e Administrador de Acesso de Usuário.

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"

Reveja a saída. Por exemplo:

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

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

A saída é mapeada para os seguintes parâmetros. Você usa esses parâmetros em etapas posteriores, com comandos de automação.

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

spn_id appId

spn_secret password

tenant_id tenant

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

Opcionalmente, atribua a função de Administrador de Acesso de 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 de Administrador de Acesso de Usuário à entidade de serviço, não poderá atribuir permissões usando a automação.

Configurar as credenciais do aplicativo Web do plano de controle

Como parte do plano de controle da estrutura de automação SAP, você pode, opcionalmente, criar um aplicativo Web interativo que o auxilie na criação dos arquivos de configuração necessários.

Screenshot that shows the web app front page.

Criar um registo de aplicação

Se você quiser usar o aplicativo Web, você deve primeiro criar um registro de aplicativo para fins de autenticação. Abra o Cloud Shell e execute os seguintes comandos:

Substitua o LAB pelo seu 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}"

Nota

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

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

A saída é mapeada para os seguintes parâmetros. Você usa esses parâmetros em etapas posteriores, com comandos de automação.

Nome de entrada do parâmetro	Nome da 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 a partir do Cloud Shell.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
code .

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

Encontre os arquivos da variável Terraform na subpasta apropriada. Por exemplo, o DEPLOYER arquivo de variável Terraform pode se parecer com 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 dos arquivos da variável Terraform para futuras edições durante a implantação.

Encontre os arquivos da variável Terraform para a Biblioteca SAP na subpasta apropriada. Por exemplo, o LIBRARY arquivo de variável Terraform pode se parecer com 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 dos arquivos da variável Terraform para futuras edições durante a implantação.

Importante

Certifique-se de que o corresponde à dns_label sua instância do DNS Privado do Azure.

Implantar o plano de controle

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

A implantação passa por ciclos de implantação da infraestrutura, atualização do estado e upload dos arquivos de estado 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, além de alguns outros parâmetros.

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

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

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 implementador e a Biblioteca SAP e adicione os detalhes da entidade de serviço ao cofre da chave de implantação usando este 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 o token-cachearquivo . Em seguida, execute az login para autenticar novamente.

Aguarde até que a estrutura de automação execute as operações plan Terraform 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                       #
#                                                                                       #
#########################################################################################

Aceda ao portal do Azure.

Selecione Grupos de recursos. Procure 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 implantador e do grupo de recursos da Biblioteca SAP é mostrado aqui.

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

Problemas conhecidos e soluções

Aqui estão algumas dicas de solução de problemas:

Se você receber o seguinte erro para a criação do módulo deployer, verifique se você está no WORKSPACES diretório quando executar o script:
```
Incorrect parameter file.
The file must contain the environment attribute!!
```
O seguinte erro é 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 plano de controle é implantado, o estado Terraform é armazenado usando o back-end azurermremoto. 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 se conectar à VM do deployer:

Inicie sessão no portal do Azure.
Selecione ou pesquise por Cofres de chaves.
Na página Cofre da chave, localize o cofre da chave do implantador. O nome começa com LAB[REGION]DEP05user. Filtre por grupo de recursos ou local, se necessário.
Na seção Configurações no painel esquerdo, selecione Segredos.
Encontre e selecione o segredo que contém sshkey. Pode parecer LAB-[REGION]-DEP05-sshkey.
Na página do segredo, selecione a versão atual. Em seguida, copie o valor secreto.
Abra um editor de texto simples. Copie no valor secreto.
Salve o arquivo onde você mantém chaves SSH. Por exemplo, use C:\\Users\\<your-username>\\.ssh.
Guarde o ficheiro. Se você for solicitado a Salvar como tipo, selecione Todos os arquivos se SSH não for uma opção. Por exemplo, use deployer.ssh.
Conecte-se à VM do implantador 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 que você baixou. Para obter instruções sobre como se conectar ao implantador usando o Visual Studio Code, consulte Conectar-se ao implantador usando o Visual Studio Code. Se você estiver usando PuTTY, converta o arquivo de chave SSH primeiro usando PuTTYGen.

Nota

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

Certifique-se de que o arquivo que você usa para salvar a chave SSH pode salvar o arquivo usando o formato correto, ou seja, sem caracteres de retorno de carro (CR). Use o Visual Studio Code ou o Notepad ++.

Depois de se conectar à VM do deployer, você poderá fazer download do software SAP usando a lista de materiais (BOM).

Conectar-se à VM do implantador 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, você pode usar uma caixa de salto do Azure Bastion ou executar 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:

Inicie sessão no portal do Azure.
Vá para o grupo de recursos que contém a VM do deployer.
Conecte-se à VM usando o Azure Bastion.
O nome de usuário padrão é azureadm.
Selecione Chave Privada SSH no Cofre de Chaves do Azure.
Selecione a assinatura que contém o plano de controle.
Selecione o cofre de chaves do deployer.
Na lista de segredos, selecione o segredo que termina com -sshkey.
Ligue à VM.

O restante das tarefas deve ser executado no implantador.

Fixar o plano de controlo

O plano de controle é a parte mais crítica da estrutura de automação SAP. É importante proteger o plano de controle. Os passos seguintes ajudam-no a proteger o plano de controlo.

Você deve atualizar o arquivo de plano tfvars de controle para habilitar pontos de extremidade privados e bloquear o acesso público às contas de armazenamento e cofres de chaves.

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

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 implementador 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. Estas informações foram recolhidas no final da fase "Implantar o plano de controlo".
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 deployer:
  - 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>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, esta etapa não é necessária.

Na primeira vez que um ambiente é instanciado, uma entidade de serviço deve ser registrada. Neste tutorial, o plano de controle está no LAB ambiente e a zona de carga de trabalho também está no LAB. Por esse motivo, uma entidade de serviço deve ser registrada para o LAB meio ambiente.

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-se à VM do implantador para as etapas a seguir. Uma cópia do repositório está agora 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 implantador, vá para a Azure_SAP_Automated_Deployment pasta.

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 deployer tfstate (encontrado no tfstate contêiner)
- Nome da tfstate conta de armazenamento
- Nome do cofre da chave 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 pela conclusão da implementação. O novo grupo de recursos aparece no portal do Azure.

Preparar para implantar a infraestrutura do sistema SAP

Conecte-se à VM do implantador para as etapas a seguir. Uma cópia do repositório está agora lá.

Vá para a WORKSPACES/SYSTEM pasta e copie os arquivos de configuração de exemplo 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 e seus discos e uma instância do Balanceador de Carga Padrão do Azure. Você pode executar bancos de dados 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 Balanceador de Carga Padrão do Azure.
A camada de aplicativo, que implanta as VMs e seus discos.
A camada Web Dispatcher.

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 no portal do Azure.

Obtenha o software SAP usando a lista de materiais

A estrutura de automação oferece ferramentas para fazer download de software da SAP usando a lista técnica do SAP. O software é baixado para a Biblioteca SAP, que atua como o arquivo para todas as mídias necessárias para implantar o SAP.

O SAP BOM imita o planejador de manutenção SAP. Existem identificadores de produto relevantes e um conjunto de URLs de download.

Uma extração de exemplo de um arquivo de lista técnica 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 este exemplo de configuração, o grupo de recursos é LAB-SECE-DEP05-INFRASTRUCTURE. O nome do cofre da chave do implantador contém LABSECEDEP05user no nome. Você usa essas informações para configurar os segredos do cofre de chaves do implantador.

Conecte-se à VM do implantador para as etapas a seguir. Uma cópia do repositório está agora lá.
Adicione um segredo com o nome de usuário para sua conta de usuário SAP. Substitua <vaultName> pelo nome do cofre de chaves do implantador. Substitua <sap-username> também pelo seu nome de usuário 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 para sua conta de usuário SAP. Substitua <vaultName> pelo nome do cofre da chave do implementador e substitua <sap-password> pela senha SAP.

Nota

O uso de aspas simples quando você define sap_user_password é importante. O uso de caracteres especiais na senha pode 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 SAP para o processo de download. Em seguida, faça o download do software SAP usando os playbooks do Ansible. Execute os seguintes comandos:
```
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 cofre de chaves do Azure para o grupo de recursos do implantador.

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

Selecione quais playbooks executar.

1) BoM Downloader
3) Quit
Please select playbook:

Selecione o manual 1) BoM Downloader para fazer o download do software SAP descrito no arquivo BOM para a conta de armazenamento. Verifique se o sapbits contêiner tem todas as suas mídias para instalação.

Você pode executar o playbook 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

Se desejar, você também pode 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 de aplicações SAP

A instalação do aplicativo SAP acontece através dos playbooks do Ansible.

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

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

Verifique se você tem os seguintes arquivos nas pastas atuais: sap-parameters.yaml e L00_host.yaml.

Para um sistema SAP S/4HANA independente, há oito playbooks para executar em sequência. Uma maneira de executar os playbooks é usar o menu de configuração.

Execute o script configuration_menu.

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

Escolha os playbooks a serem executados.

Playbook: Configuração básica do sistema operacional

Este manual executa a configuração genérica do sistema operacional em todas as máquinas, o que inclui a configuração de repositórios de software, pacotes e serviços.