Começar com a implementação manual

Juntamente com a implementação automatizada, também pode fazer a implementação manual da estrutura de automatização de implantação SAP em Azure. Utilize esta configuração de exemplo e ficheiros de parâmetros de amostra para começar.

Dica

Este guia cobre apenas como efetuar uma colocação manual . Se quiser começar rapidamente, consulte o guia de implementação automatizado.

Estes passos referem-se e utilizam a convenção de nomeação padrão para o quadro de automatização. Os valores de exemplo também são usados para nomear ao longo do código. Por exemplo, o nome do desdobrador é DEMO-EUS2-DEP00-INFRASTRUCTURE. Neste exemplo, o ambiente é uma demonstração (DEMO), a região é Leste DOS 2 (EUS2), e a rede virtual de implantação é DEP00.

Pré-requisitos

Configuração do desdobrador

Antes de começar, verifique se está na subscrição correta do Azure. Em seguida, crie o seu desdobrador:

  1. Faça o download e instale o Terraform.
  2. Clone e configuure o repositório de quadros de automatização no desdobrador.
  3. Inicializar o Terraform
  4. Obtenha as suas chaves SSH para utilização no resto da sua implantação.

Verifique a subscrição do Azure

Verifique se está a utilizar a subscrição apropriada do Azure:

  1. Inicie sessão no portal do Azure.

  2. Abra a concha da nuvem Azure.

  3. Verifique se está na subscrição que pretende utilizar:

    az account list --output=table | grep -i true
    
  4. Se necessário, altere a subscrição ativa da subscrição que pretende utilizar.

Baixar Terraform

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

  1. Criar e navegar para um novo diretório, bin.

    mkdir -p ~/bin; cd $_
    
  2. Recupere o binário Terraform apropriado. Por exemplo:

    wget  https://releases.hashicorp.com/terraform/0.14.7/terraform_0.14.7_linux_amd64.zip
    
  3. Desaperte o binário Terraform. Por exemplo:

    unzip terraform_0.14.7_linux_amd64.zip
    
  4. Verifique o seu download Terraform:

    hash terraform
    
  5. Crie um diretório para a sua implementação automatizada SAP.

    mkdir -p ~/Azure_SAP_Automated_Deployment; cd $_
    

Configurar repositório

Clone e configurar o repositório de quadros de automação.

  1. Clone o repositório de GitHub:

    git clone https://github.com/Azure/sap-automation.git
    
  2. Navegue para a pasta sap-automation.

    cd  ~/Azure_SAP_Automated_Deployment/sap-automation
    
  3. Opcionalmente, confira um ramo diferente do ramo principal. O ramo principal do repositório é o padrão.

    1. Substitua <branch> pelo nome do ramo ou consolide o hash que quer utilizar.

      git checkout <branch>
      
    2. Verifique se a sua sucursal está na revisão esperada.

      git rev-parse HEAD
      

Inicializar o Terraform

  1. Criar um diretório de trabalho. O nome do diretório deve observar a convenção de nomeação padrão. Por exemplo:

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/DEMO-EUS2-DEP00-INFRASTRUCTURE; cd $_
    
  2. Crie o ficheiro 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
    
  3. Inicie o Terraform.

    terraform init  ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/
    
  4. Crie um plano de execução Terraform que siga a convenção de nomeação padrão.

    terraform plan                                                                    \
                    --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                    \
                    ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/
    
  5. Aplique o seu plano de execução Terraform para mobilizar os recursos.

    terraform apply --auto-approve                                                    \
                    --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                    \
                    ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/
    
  6. Reparem na saída.

Obter chaves SSH

  1. Utilizando a saída da implantação do Terraform, observe os valores para os seguintes campos.

    1. Endereço IP público: deployer_public_ip_address.

    2. Nome de utilizador do cofre da chave: deployer_kv_user_name.

    3. Nome do cofre privado: 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.

  2. Executar o script pós-processamento.

    ./post_deployment.sh
    
  3. Extrair a chave SSH privada:

    az keyvault secret show               \
      --vault-name DEMOEUS2DEP00userE27   \
      --name DEMO-EUS2-DEP00-sshkey     | \
      jq -r .value > sshkey
    
    
  4. Extrair a chave SSH pública:

    az keyvault secret show               \
      --vault-name DEMOEUS2DEP00userF6A   \
      --name DEMO-EUS2-DEP00-sshkey-pub | \
      jq -r .value > sshkey.pub
    
    
  5. Baixe o par de chaves privada e pública. No menu Cloud Shell, selecione Upload/DownloadfilesDownload>.

Configuração principal do serviço

O desdobrador utiliza um principal de serviço para implantar recursos numa subscrição.

  1. Inscreva-se no Azure CLI.

    az login
    
  2. Criar um diretor de serviço. Certifique-se de que substitui <subscription-id> pelo seu identificador de assinatura Azure. Substitua <sp-name> também um nome para o seu diretor de serviço.

    az ad sp create-for-rbac --role="Contributor" --scopes="/subscriptions/<subscription-id>" --name="<sp-name>"
    
  3. Note a saída, que contém informações sobre o principal serviço. Copiar os valores dos seguintes campos:

    1. Identificador de aplicação: appId.

    2. Senha: password.

    3. Identificador de inquilino: tenant.

  4. Crie uma atribuição de funções para o diretor de serviço. Certifique-se de que <appId> substitui pelo identificador de aplicações que notou no passo anterior.

    az role assignment create --assignee <appId> --role "User Access Administrator" --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group-name>
    
  5. Adicione as chaves do principal de serviço ao cofre da chave da seguinte forma. Certifique-se de que substitui os valores do espaço reservado pelas informações que notou nos passos anteriores. Substitua-o pelo <environment> nome do seu ambiente, tal 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

  1. Inscreva-se no desdobrador utilizando o seu cliente SSH e as chaves SSH que recuperou durante a configuração do desdobrador. Se estiver a utilizar o PuTTY como cliente SSH, converta as teclas SSH no .ppk formato antes de utilizar.

  2. Navegue para onde clonou o repositório de quadros de automação.

    cd  ~/Azure_SAP_Automated_Deployment/sap-automation
    
  3. Opcionalmente, confira um ramo diferente do ramo principal. O ramo principal do repositório é o padrão.

    1. Substitua <branch> pelo nome do ramo ou consolide o hash que quer utilizar.

      git checkout <branch>
      
    2. Verifique se a sua sucursal está na revisão esperada.

      git rev-parse HEAD
      
  4. Criar um diretório de trabalho.

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/DEMO-EUS2-SAP_LIBRARY; cd $_
    
  5. Crie o ficheiro de configuração JSON.

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

    terraform init  ../../../sap-automation/deploy/terraform/bootstrap/sap_library/
    
  7. Crie um plano de execução Terraform que siga a convenção de nomeação padrão.

    terraform plan                                                                  \
                --var-file=DEMO-EUS2-SAP_LIBRARY.json                           \
                ../../../sap-automation/deploy/terraform/bootstrap/sap_library
    
    
  8. Aplique o seu plano de execução Terraform para mobilizar os recursos.

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

Reinitializar implantação

Reinitialize tanto o desdobrador como a biblioteca SAP.

Reinitializar o desdobrador

  1. Mantenha-se inscrito no seu destacador no cliente SSH. Ou, inscreva-se de novo.

  2. Navegue para o diretório de trabalho que criou.

    cd ~/Azure_SAP_Automated_Deployment/WORKSPACES/LOCAL/DEMO-EUS2-DEP00-INFRASTRUCTURE
    
  3. Criar outro ficheiro de parâmetro chamado backend. Mais uma vez, siga as convenções de nomeação padrão. Para resource_group_name, utilize o nome do grupo de recursos onde está localizada a conta de armazenamento com os seus ficheiros de estado Terraform (.tfstate). Para storage_account_name, substitua-a pelo <tfstate_storage_account_name> nome da conta de armazenamento da implantação da Biblioteca SAP por .tfstate ficheiros. Para key, combinar 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
    
  4. Inicialize terraform novamente.

    terraform init  --backend-config backend                                        \
                    ../../../sap-automation/deploy/terraform/run/sap_deployer/
    
  5. Quando solicitado Deseja copiar o estado existente para o novo backend?, insira yes.

  6. Retire o ficheiro do estado local.

    rm terraform.tfstate*
    
  7. Criar um plano de execução Terraform. Mais uma vez, siga as convenções de nomeação padrão. Por exemplo:

    terraform plan                                                                  \
                    --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                  \
                    ../../../sap-automation/deploy/terraform/run/sap_deployer/
    
  8. 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/
    

Reinitializar Biblioteca SAP

  1. Mantenha-se inscrito no seu destacador no cliente SSH. Ou, inscreva-se de novo.

  2. Navegue para o diretório de trabalho que criou.

    cd ~/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/DEMO-EUS2-SAP_LIBRARY
    
  3. Criar outro ficheiro de parâmetro chamado backend. Mais uma vez, siga as convenções de nomeação padrão. Para resource_group_name, utilize o nome do grupo de recursos onde está localizada a conta de armazenamento com os seus ficheiros de estado Terraform (.tfstate). Para storage_account_name, substitua-a pelo <tfstate_storage_account_name> nome da conta de armazenamento da implantação da Biblioteca SAP por .tfstate ficheiros. Para key, combinar 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
    
  4. Adicione um novo par de valores-chave imediatamente após o suporte de abertura ({) do ficheiro backendde parâmetros . Para tfstate_resource_id, utilize o identificador de recursos para a conta de armazenamento de ficheiros do estado Terraform. Para deployer_tfstate_key, utilize o nome chave para o ficheiro de estado do desdobrador. Por exemplo:

    {
        "tfstate_resource_id"                   : "<identifier>",
        "deployer_tfstate_key"                  : "<key>",
        "infrastructure": {
            ...
    }
    
  5. Inicialize terraform novamente.

    terraform init  --backend-config backend                                          \
                    ../../../sap-automation/deploy/terraform/run/sap_library/
    
  6. Quando solicitado Deseja copiar o estado existente para o novo backend?, insira yes.

  7. Retire o ficheiro do estado local.

    rm terraform.tfstate*
    
  8. Criar um plano de execução Terraform. Mais uma vez, siga as convenções de nomeação padrão. Por exemplo:

    terraform plan                                                                    \
                    --var-file=DEMO-EUS2-SAP_LIBRARY.json                             \
                    ../../../sap-automation/deploy/terraform/run/sap_library/
    
  9. 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/
    

Implementar rede virtual de carga de trabalho

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

  1. Mantenha-se inscrito no seu destacador no cliente SSH. Ou, inscreva-se de novo.

  2. Criar um diretório de trabalho. Siga as convenções de nomeação padrão.

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/LANDSCAPE/DEMO-EUS2-SAP00-INFRASTRUCTURE; cd $_
    
  3. Criar um ficheiro de parâmetros chamado backend. Para resource_group_name, utilize o nome do grupo de recursos onde está localizada a conta de armazenamento com os seus ficheiros de estado Terraform (.tfstate). Para storage_account_name, substitua-a pelo <tfstate_storage_account_name> nome da conta de armazenamento da implantação da Biblioteca SAP por .tfstate ficheiros. Para key, combinar 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
    
  4. Inicialize terraform novamente.

    terraform init  --backend-config backend                                        \
                    ../../../sap-automation/deploy/terraform/run/sap_landscape/
    
  5. Criar um plano de execução Terraform. Mais uma vez, siga as convenções de nomeação padrão. Por exemplo:

    terraform plan                                                                  \
                --var-file=DEMO-EUS2-SAP00-INFRASTRUCTURE.json                  \
                ../../../sap-automation/deploy/terraform/run/sap_landscape/
    
  6. 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 implantação SAP

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

  1. Mantenha-se inscrito no seu destacador no cliente SSH. Ou, inscreva-se novamente

  2. Criar um diretório de trabalho. Siga as convenções de nomeação padrão.

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/SYSTEM/DEMO-EUS2-SAP00-X00; cd $_
    
  3. Criar outro ficheiro de parâmetro chamado backend. Para resource_group_name, utilize o nome do grupo de recursos onde está localizada a conta de armazenamento com os seus ficheiros de estado Terraform (.tfstate). Para storage_account_name, substitua-a pelo <tfstate_storage_account_name> nome da conta de armazenamento da implantação da Biblioteca SAP por .tfstate ficheiros. Para key, combinar 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
    
  4. Crie um ficheiro de parâmetro JSON com parâmetros de entrada da seguinte forma. Certifique-se de que substitui os valores da 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
    
  5. Inicialize terraform novamente.

    terraform init  --backend-config backend                                        \
                    ../../../sap-automation/deploy/terraform/run/sap_system/
    
    
  6. Criar um plano de execução Terraform. Mais uma vez, siga as convenções de nomeação padrão. Por exemplo:

    terraform plan                                                                  \
                    --var-file=DEMO-EUS2-SAP00-X00.json                             \
                    ../../../sap-automation/deploy/terraform/run/sap_system/
    
  7. 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 ansível

Configure a sua configuração executando livros de reprodução Ansible. Estes livros estão localizados no repositório de quadros de automação em /sap-automation/deploy/ansible.

Nome de arquivo Description
playbook_01_os_base_config.yaml Configuração do sistema operativo base (OS)
playbook_02_os_sap_specific_config.yaml Configuração de SO específica do SAP
playbook_03_bom_processing.yaml Download de software de processamento DA CARTA DE MATERIAIS SAP (BOM)
playbook_04a_sap_scs_install.yaml Instalação de serviços centrais SAP (SCS)
playbook_05a_hana_db_install.yaml Instalação da base de dados SAP HANA
playbook_06a_sap_dbload.yaml Carregador de base de dados
playbook_06b_sap_pas_install.yaml Instalação do servidor de aplicações primárias SAP (PAS)
playbook_06c_sap_app_install.yaml Instalação do servidor de aplicações SAP
playbook_06d_sap_web_install.yaml Instalação do despachante web SAP
playbook_06_00_00_pacemaker.yaml Configuração do cluster pacemaker
playbook_06_00_01_pacemaker_scs.yaml Configuração do Pacemaker para SCS
playbook_06_00_03_pacemaker_hana.yaml Configuração do pacemaker para base de dados SAP HANA

Para executar um livro de jogadas ou vários livros, utilize o comando ansible-playbook da seguinte forma. Certifique-se de alterar todos os valores de espaço reservado para a sua própria informação:

  • Mude <your-sapbits-path> para o caminho para a sua conta sapbits de armazenamento para a Biblioteca SAP.
  • Altere <azure-admin> para o seu nome de utilizador administrador Azure.
  • Mude <ssh-key> para a chave SSH privada que pretende utilizar.
  • Altere outros valores conforme --extra-vars necessário para as suas definições.

Se tiver problemas, certifique-se de que descarregou o software SAP para o seu ambiente Azure.

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


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

Passos seguintes