Introdução à implantação manual

Artigo
10/27/2023

Junto com a implantação automatizada, você também pode fazer a implantação manual do SAP no Azure Deployment Automation Framework. Use este exemplo de configuração e arquivos de parâmetros de exemplo para começar.

Gorjeta

Este guia aborda apenas como executar uma implantação manual . Se você quiser começar rapidamente, consulte o guia de implantação automatizada.

Essas etapas fazem referência e usam a convenção de nomenclatura padrão para a estrutura de automação. Valores de exemplo também são usados para nomear todo o código. Por exemplo, o nome do implantador é DEMO-EUS2-DEP00-INFRASTRUCTURE. Neste exemplo, o ambiente é uma demonstração (), a região é East US 2 (DEMO) e a rede virtual do implantador é DEP00.EUS2

Pré-requisitos

Uma subscrição do Azure. Se não tiver uma subscrição do Azure, pode criar uma conta gratuita.
Uma conta do Azure com privilégios para criar uma entidade de serviço.
Um download do software SAP em seu ambiente do Azure.

Configuração do Deployer

Antes de começar, verifique se você está na assinatura correta do Azure. Em seguida, configure o implantador:

Baixe e instale o Terraform.
Clone e configure o repositório da estrutura de automação no implantador.
Inicializar Terraform
Obtenha suas chaves SSH para uso no restante da implantação.

Verificar a subscrição do Azure

Verifique se você está usando a assinatura apropriada do Azure:

Inicie sessão no portal do Azure.
Abra o Azure Cloud Shell.
Verifique se você está na assinatura que deseja usar:
```
az account list --output=table | grep -i true
```
Se necessário, altere a subscrição ativa para a subscrição que pretende utilizar.

Baixar Terraform

Faça o download do Terraform para o seu ambiente:

Crie e navegue até um novo diretório, bin.
```
mkdir -p ~/bin; cd $_
```

Recupere o binário Terraform apropriado. Por exemplo:

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

Descompacte o binário Terraform. Por exemplo:
```
unzip terraform_0.14.7_linux_amd64.zip
```
Verifique o download do Terraform:
```
hash terraform
```
Crie um diretório para sua implantação automatizada SAP.
```
mkdir -p ~/Azure_SAP_Automated_Deployment; cd $_
```

Configurar repositório

Clone e configure o repositório da estrutura de automação.

Clone o repositório do GitHub:

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

Navegue para a pasta sap-automation.

cd  ~/Azure_SAP_Automated_Deployment/sap-automation

Opcionalmente, confira um ramo diferente do ramo principal. A ramificação principal do repositório é o padrão.
1. Substitua <branch> pelo nome da ramificação ou hash de confirmação que você deseja usar.
```
git checkout <branch>
```
2. Verifique se a sua filial está na revisão esperada.
```
git rev-parse HEAD
```

Inicializar o Terraform

Crie um diretório de trabalho. O nome do diretório deve observar a convenção de nomenclatura padrão. Por exemplo:
```
mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/DEMO-EUS2-DEP00-INFRASTRUCTURE; cd $_
```

Crie o arquivo de parâmetro 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

Inicialize o Terraform.

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

Crie um plano de execução do Terraform que siga a convenção de nomenclatura padrão.

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

Aplique seu plano de execução Terraform para implantar os recursos.

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

Observe a saída.

Obter chaves SSH

Usando a saída da implantação do Terraform, observe os valores para os campos a seguir.
1. Endereço IP público: deployer_public_ip_address.
2. Nome de utilizador do cofre de chaves: deployer_kv_user_name.
3. Nome do cofre de chave privada: deployer_kv_prvt_name.
4. Nome da chave pública: deployer_public_key_secret_name.
5. Nome da chave privada: deployer_private_key_secret_name.
Execute o script de pós-processamento.
```
./post_deployment.sh
```

Extraia a chave SSH privada:

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

Extraia a chave SSH pública:

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

Faça o download do par de chaves pública e privada. No menu Cloud Shell, selecione Upload/Download de arquivos>Download.

Configuração da entidade de serviço

O implantador usa uma entidade de serviço para implantar recursos em uma assinatura.

Entre na CLI do Azure.
```
az login
```
Crie uma entidade de serviço. Certifique-se de substituir <subscription-id> pelo seu identificador de assinatura do Azure. Substitua <sp-name> também por um nome para a entidade de serviço.
```
az ad sp create-for-rbac --role="Contributor" --scopes="/subscriptions/<subscription-id>" --name="<sp-name>"
```
Observe a saída, que contém informações sobre a entidade de serviço. Copie os valores dos seguintes campos:
1. Identificador da aplicação: appId.
2. Palavra-passe: password.
3. Identificador do locatário: tenant.
Crie uma atribuição de função para a entidade de serviço. Certifique-se de substituir <appId> pelo identificador de aplicativo que você anotou na etapa anterior.
```
az role assignment create --assignee <appId> --role "User Access Administrator" --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group-name>
```

Adicione chaves para a entidade de serviço ao cofre de chaves da seguinte maneira. Certifique-se de substituir os valores de espaço reservado pelas informações que você anotou nas etapas anteriores. Substitua <environment> pelo nome do seu ambiente, como 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>";

Configuração da biblioteca

Entre no implantador usando seu cliente SSH e as chaves SSH recuperadas durante a configuração do implantador. Se você estiver usando o PuTTY como seu cliente SSH, converta as chaves SSH para .ppk o formato antes de usar.
Navegue até onde você clonou o repositório da estrutura de automação.
```
cd  ~/Azure_SAP_Automated_Deployment/sap-automation
```
Opcionalmente, confira um ramo diferente do ramo principal. A ramificação principal do repositório é o padrão.
1. Substitua <branch> pelo nome da ramificação ou hash de confirmação que você deseja usar.
```
git checkout <branch>
```
2. Verifique se a sua filial está na revisão esperada.
```
git rev-parse HEAD
```

Crie um diretório de trabalho.

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

Crie o arquivo de configuração JSON.

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

Inicialize o Terraform.

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

Crie um plano de execução do Terraform que siga a convenção de nomenclatura padrão.

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

Aplique seu plano de execução Terraform para implantar os recursos.

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

Reinicializar a implantação

Reinicialize o implementador e a biblioteca SAP.

Reinicializar implantador

Permaneça conectado ao seu implantador no cliente SSH. Ou inicie sessão novamente.

Navegue até o diretório de trabalho que você criou.

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

Crie outro arquivo de parâmetro chamado backend. Novamente, siga as convenções de nomenclatura padrão. Para resource_group_name, use o nome do grupo de recursos onde a conta de armazenamento com seus arquivos de estado Terraform (.tfstate) está localizada. Para storage_account_name, substitua <tfstate_storage_account_name> pelo nome da conta de armazenamento da implantação da Biblioteca SAP para .tfstate arquivos. Para key, combine o nome do grupo de recursos do implantador com a extensão .terraform.tfstate. Por exemplo:
```
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
```

Inicialize o Terraform novamente.

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

Quando solicitado Deseja copiar o estado existente para o novo back-end?, digite yes.
Remova o arquivo de estado local.
```
rm terraform.tfstate*
```

Crie um plano de execução Terraform. Novamente, siga as convenções de nomenclatura padrão. Por exemplo:

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

Aplique o plano de execução Terraform. Por exemplo:

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

Reinicializar a biblioteca SAP

Permaneça conectado ao seu implantador no cliente SSH. Ou inicie sessão novamente.

Navegue até o diretório de trabalho que você criou.

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

Crie outro arquivo de parâmetro chamado backend. Novamente, siga as convenções de nomenclatura padrão. Para resource_group_name, use o nome do grupo de recursos onde a conta de armazenamento com seus arquivos de estado Terraform (.tfstate) está localizada. Para storage_account_name, substitua <tfstate_storage_account_name> pelo nome da conta de armazenamento da implantação da Biblioteca SAP para .tfstate arquivos. Para key, combine o nome do grupo de recursos do implantador com a extensão .terraform.tfstate. Por exemplo:
```
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
```
Adicione um novo par chave-valor imediatamente após o colchete de abertura ({) do arquivo backendde parâmetros. Para tfstate_resource_id, use o identificador de recurso para a conta de armazenamento de arquivo de estado Terraform. Para deployer_tfstate_key, use o nome da chave para o arquivo de estado do implantador. Por exemplo:
```
{
    "tfstate_resource_id"                   : "<identifier>",
    "deployer_tfstate_key"                  : "<key>",
    "infrastructure": {
        ...
}
```

Inicialize o Terraform novamente.

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

Quando solicitado Deseja copiar o estado existente para o novo back-end?, digite yes.
Remova o arquivo de estado local.
```
rm terraform.tfstate*
```

Crie um plano de execução Terraform. Novamente, siga as convenções de nomenclatura padrão. Por exemplo:

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

Aplique o plano de execução Terraform. Por exemplo:

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

Implantar rede virtual de carga de trabalho

Em seguida, implante a rede virtual de carga de trabalho SAP.

Permaneça conectado ao seu implantador no cliente SSH. Ou inicie sessão novamente.

Crie um diretório de trabalho. Siga as convenções de nomenclatura padrão.

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

Crie um arquivo de parâmetro chamado backend. Para resource_group_name, use o nome do grupo de recursos onde a conta de armazenamento com seus arquivos de estado Terraform (.tfstate) está localizada. Para storage_account_name, substitua <tfstate_storage_account_name> pelo nome da conta de armazenamento da implantação da Biblioteca SAP para .tfstate arquivos. Para key, combine o nome do grupo de recursos do implantador com a extensão .terraform.tfstate. Por exemplo:
```
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
```

Inicialize o Terraform novamente.

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

Crie um plano de execução Terraform. Novamente, siga as convenções de nomenclatura padrão. Por exemplo:

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

Aplique o plano de execução Terraform. Por exemplo:

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

Unidade de implementação SAP

Em seguida, configure a unidade de implantação SAP.

Permaneça conectado ao seu implantador no cliente SSH. Ou inicie sessão novamente

Crie um diretório de trabalho. Siga as convenções de nomenclatura padrão.

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

Crie outro arquivo de parâmetro chamado backend. Para resource_group_name, use o nome do grupo de recursos onde a conta de armazenamento com seus arquivos de estado Terraform (.tfstate) está localizada. Para storage_account_name, substitua <tfstate_storage_account_name> pelo nome da conta de armazenamento da implantação da Biblioteca SAP para .tfstate arquivos. Para key, combine o nome do grupo de recursos do implantador com a extensão .terraform.tfstate. Por exemplo:
```
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
```

Crie um arquivo de parâmetros JSON com parâmetros de entrada da seguinte maneira. Certifique-se de substituir os valores de amostra pelos seus.

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

Inicialize o Terraform novamente.

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

Crie um plano de execução Terraform. Novamente, siga as convenções de nomenclatura padrão. Por exemplo:

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

Aplique o plano de execução Terraform. Por exemplo:

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

Configuração do Ansible

Configure sua configuração executando playbooks do Ansible. Esses playbooks estão localizados no repositório da estrutura de automação em /sap-automation/deploy/ansible.

Nome do ficheiro	Descrição
`playbook_01_os_base_config.yaml`	Configuração do sistema operacional (SO) de base
`playbook_02_os_sap_specific_config.yaml`	Configuração do SO específico do SAP
`playbook_03_bom_processing.yaml`	Download do software de processamento SAP Bill of Materials (BOM)
`playbook_04a_sap_scs_install.yaml`	Instalação de serviços centrais SAP (SCS)
`playbook_05a_hana_db_install.yaml`	Instalação do banco de dados SAP HANA
`playbook_06a_sap_dbload.yaml`	Carregador de banco de dados
`playbook_06b_sap_pas_install.yaml`	Instalação do servidor de aplicativos primário (PAS) SAP
`playbook_06c_sap_app_install.yaml`	Instalação do servidor de aplicativos SAP
`playbook_06d_sap_web_install.yaml`	Instalação do SAP web dispatcher
`playbook_06_00_00_pacemaker.yaml`	Configuração do cluster Pacemaker
`playbook_06_00_01_pacemaker_scs.yaml`	Configuração de marcapasso para SCS
`playbook_06_00_03_pacemaker_hana.yaml`	Configuração do Pacemaker para banco de dados SAP HANA

Para executar um playbook ou vários playbooks, use o comando ansible-playbook da seguinte maneira. Certifique-se de alterar todos os valores de espaço reservado para suas próprias informações:

Mude <your-sapbits-path> para o caminho para sua conta sapbits de armazenamento para a Biblioteca SAP.
Mude <azure-admin> para seu nome de usuário de administrador do Azure.
Mude <ssh-key> para a chave SSH privada que você deseja usar.
Altere outros valores em --extra-vars conforme necessário para suas configurações.

Se tiver problemas, certifique-se de que transferiu o software SAP para o seu ambiente do 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

Próximos passos

Comece rapidamente com uma implantação automatizada

Partilhar via

Introdução à implantação manual

Pré-requisitos

Configuração do Deployer

Verificar a subscrição do Azure

Baixar Terraform

Configurar repositório

Inicializar o Terraform

Obter chaves SSH

Configuração da entidade de serviço

Configuração da biblioteca

Reinicializar a implantação

Reinicializar implantador

Reinicializar a biblioteca SAP

Implantar rede virtual de carga de trabalho

Unidade de implementação SAP

Configuração do Ansible

Próximos passos

Comentários

Recursos adicionais