Introducción a la implementación manual

Junto con la implementación automatizada, también puede realizar la implementación manual del marco de automatización de la implementación de SAP en Azure. Use esta configuración de ejemplo y los archivos de parámetros de ejemplo para empezar.

Sugerencia

En esta guía solo se explica cómo realizar una implementación manual. Si quiere empezar a trabajar rápidamente, consulte en su lugar la guía de implementación automatizada.

Estos pasos usan la convención de nomenclatura predeterminada para el marco de automatización y hacen referencia a ella. Los valores de ejemplo también se usan para asignar nombres a lo largo del código. Por ejemplo, el nombre del implementador es DEMO-EUS2-DEP00-INFRASTRUCTURE. En este ejemplo, el entorno es una demostración (DEMO), la región es Este de EE. UU. 2 (EUS2) y la red virtual del implementador es DEP00.

Requisitos previos

  • Suscripción a Azure. Si no tiene una suscripción a Azure, puede crear una cuenta gratuita.
  • Una cuenta de Azure con privilegios para crear una entidad de servicio.
  • Una descarga del software de SAP en el entorno de Azure.

Configuración del implementador

Antes de empezar, compruebe que está en la suscripción de Azure correcta. A continuación, configure el implementador:

  1. Descargue e instale Terraform.
  2. Clone y configure el repositorio del marco de automatización en el implementador.
  3. Inicialización de Terraform
  4. Obtenga las claves SSH para usarlas en el resto de la implementación.

Comprobación de la suscripción de Azure

Compruebe que usa la suscripción de Azure adecuada:

  1. Inicie sesión en Azure Portal.

  2. Abra Azure Cloud Shell.

  3. Compruebe que está en la suscripción que desea usar:

    az account list --output=table | grep -i true
    
  4. Si es necesario, cambie la suscripción activa a la suscripción que desea usar.

Descarga de Terraform

Descargue Terraform en su entorno:

  1. Cree un nuevo directorio, bin, y vaya a él.

    mkdir -p ~/bin; cd $_
    
  2. Recupere el binario de Terraform adecuado. Por ejemplo:

    wget  https://releases.hashicorp.com/terraform/0.14.7/terraform_0.14.7_linux_amd64.zip
    
  3. Descomprima el binario de Terraform. Por ejemplo:

    unzip terraform_0.14.7_linux_amd64.zip
    
  4. Compruebe la descarga de Terraform:

    hash terraform
    
  5. Cree un directorio para la implementación automatizada de SAP.

    mkdir -p ~/Azure_SAP_Automated_Deployment; cd $_
    

Configuración del repositorio

Clone y configure el repositorio del marco de automatización.

  1. Clone el repositorio de GitHub:

    git clone https://github.com/Azure/sap-automation.git
    
  2. Vaya a la carpeta sap-automation.

    cd  ~/Azure_SAP_Automated_Deployment/sap-automation
    
  3. Opcionalmente, consulte una rama diferente de la rama principal. La rama principal del repositorio es la predeterminada.

    1. Reemplace <branch> por el nombre de rama o el hash de confirmación que desea usar.

      git checkout <branch>
      
    2. Compruebe que la rama está en la revisión esperada.

      git rev-parse HEAD
      

Inicialización de Terraform

  1. Cree un directorio de trabajo. El nombre del directorio debe observar la convención de nomenclatura predeterminada. Por ejemplo:

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/DEMO-EUS2-DEP00-INFRASTRUCTURE; cd $_
    
  2. Cree el archivo de parámetros 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. Inicialice Terraform.

    terraform init  ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/
    
  4. Cree un plan de ejecución de Terraform que siga la convención de nomenclatura predeterminada.

    terraform plan                                                                    \
                    --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                    \
                    ../../../sap-automation/deploy/terraform/bootstrap/sap_deployer/
    
  5. Aplique el plan de ejecución de Terraform para implementar los recursos.

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

Obtención de las claves SSH

  1. Con la salida de la implementación de Terraform, tenga en cuenta los valores de los campos siguientes.

    1. Dirección IP pública: deployer_public_ip_address.

    2. Nombre de usuario del almacén de claves: deployer_kv_user_name.

    3. Nombre del almacén de claves privado: deployer_kv_prvt_name.

    4. Nombre de la clave pública: deployer_public_key_secret_name.

    5. Nombre de la clave privada: deployer_private_key_secret_name.

  2. Ejecute el script de procesamiento posterior.

    ./post_deployment.sh
    
  3. Extraiga la clave SSH privada:

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

    az keyvault secret show               \
      --vault-name DEMOEUS2DEP00userF6A   \
      --name DEMO-EUS2-DEP00-sshkey-pub | \
      jq -r .value > sshkey.pub
    
    
  5. Descargue el par de claves pública y privada. En el menú de Cloud Shell, seleccione Cargar/Descargar archivos>Descargar.

Configuración de la entidad de servicio

El implementador usa una entidad de servicio para implementar recursos en una suscripción.

  1. Inicie sesión en la CLI de Azure.

    az login
    
  2. Crear una entidad de servicio. Asegúrese de reemplazar <subscription-id> por el id. de su suscripción de Azure. Reemplace también <sp-name> por un nombre para la entidad de servicio.

    az ad sp create-for-rbac --role="Contributor" --scopes="/subscriptions/<subscription-id>" --name="<sp-name>"
    
  3. Observe la salida, que contiene información sobre la entidad de servicio. Copie los valores de los siguientes campos:

    1. Identificador de aplicación: appId.

    2. Contraseña: password.

    3. Identificador de inquilino: tenant.

  4. Cree una asignación de roles para la entidad de servicio. Asegúrese de reemplazar <appId> por el identificador de aplicación que anotó en el paso anterior.

    az role assignment create --assignee <appId> --role "User Access Administrator" --scope /subscriptions/<subscription-id>/resourceGroups/<resource-group-name>
    
  5. Agregue claves para la entidad de servicio al almacén de claves como se muestra a continuación. Asegúrese de reemplazar los valores de marcador de posición por la información que anotó en los pasos anteriores. Reemplace <environment> por el nombre del entorno, por ejemplo, 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>";
    

Configuración de la biblioteca

  1. Inicie sesión en el implementador mediante el cliente SSH y las claves SSH que recuperó durante la instalación del implementador. Si usa PuTTY como cliente SSH, convierta las claves SSH al formato .ppk antes de su uso.

  2. Vaya a donde ha clonado el repositorio del marco de automatización.

    cd  ~/Azure_SAP_Automated_Deployment/sap-automation
    
  3. Opcionalmente, consulte una rama diferente de la rama principal. La rama principal del repositorio es la predeterminada.

    1. Reemplace <branch> por el nombre de rama o el hash de confirmación que desea usar.

      git checkout <branch>
      
    2. Compruebe que la rama está en la revisión esperada.

      git rev-parse HEAD
      
  4. Cree un directorio de trabajo.

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/DEMO-EUS2-SAP_LIBRARY; cd $_
    
  5. Cree el archivo de configuración JSON.

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

    terraform init  ../../../sap-automation/deploy/terraform/bootstrap/sap_library/
    
  7. Cree un plan de ejecución de Terraform que siga la convención de nomenclatura predeterminada.

    terraform plan                                                                  \
                --var-file=DEMO-EUS2-SAP_LIBRARY.json                           \
                ../../../sap-automation/deploy/terraform/bootstrap/sap_library
    
    
  8. Aplique el plan de ejecución de Terraform para implementar los recursos.

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

Reinicialización de la implementación

Reinicialice el implementador y la biblioteca SAP.

Reinicialización del implementador

  1. Mantenga la sesión iniciada en el implementador en el cliente SSH. O vuelva a iniciar sesión.

  2. Navegue al directorio de trabajo que creó.

    cd ~/Azure_SAP_Automated_Deployment/WORKSPACES/LOCAL/DEMO-EUS2-DEP00-INFRASTRUCTURE
    
  3. Cree otro archivo de parámetros denominado backend. De nuevo, siga las convenciones de nomenclatura predeterminadas. Para resource_group_name, use el nombre del grupo de recursos donde se encuentra la cuenta de almacenamiento con los archivos de estado de Terraform (.tfstate). Para storage_account_name, reemplace <tfstate_storage_account_name> por el nombre de la cuenta de almacenamiento de la implementación de la biblioteca SAP para archivos .tfstate. Para key, combine el nombre del grupo de recursos del implementador con la extensión .terraform.tfstate. Por ejemplo:

    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. Vuelva a inicializar Terraform.

    terraform init  --backend-config backend                                        \
                    ../../../sap-automation/deploy/terraform/run/sap_deployer/
    
  5. Cuando se le solicite ¿Desea copiar el estado existente en el nuevo back-end? , escriba yes.

  6. Quite el archivo de estado local.

    rm terraform.tfstate*
    
  7. Creación de un plan de ejecución de Terraform. De nuevo, siga las convenciones de nomenclatura predeterminadas. Por ejemplo:

    terraform plan                                                                  \
                    --var-file=DEMO-EUS2-DEP00-INFRASTRUCTURE.json                  \
                    ../../../sap-automation/deploy/terraform/run/sap_deployer/
    
  8. Aplique un plan de ejecución de Terraform. Por ejemplo:

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

Reinicialización de la biblioteca SAP

  1. Mantenga la sesión iniciada en el implementador en el cliente SSH. O vuelva a iniciar sesión.

  2. Navegue al directorio de trabajo que creó.

    cd ~/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/DEMO-EUS2-SAP_LIBRARY
    
  3. Cree otro archivo de parámetros denominado backend. De nuevo, siga las convenciones de nomenclatura predeterminadas. Para resource_group_name, use el nombre del grupo de recursos donde se encuentra la cuenta de almacenamiento con los archivos de estado de Terraform (.tfstate). Para storage_account_name, reemplace <tfstate_storage_account_name> por el nombre de la cuenta de almacenamiento de la implementación de la biblioteca SAP para archivos .tfstate. Para key, combine el nombre del grupo de recursos del implementador con la extensión .terraform.tfstate. Por ejemplo:

    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. Agregue un nuevo par clave-valor inmediatamente después del corchete de apertura ({) del archivo de parámetros backend. Para tfstate_resource_id, use el identificador de recurso para la cuenta de almacenamiento de archivos de estado de Terraform. Para deployer_tfstate_key, use el nombre de clave para el archivo de estado del implementador. Por ejemplo:

    {
        "tfstate_resource_id"                   : "<identifier>",
        "deployer_tfstate_key"                  : "<key>",
        "infrastructure": {
            ...
    }
    
  5. Vuelva a inicializar Terraform.

    terraform init  --backend-config backend                                          \
                    ../../../sap-automation/deploy/terraform/run/sap_library/
    
  6. Cuando se le solicite ¿Desea copiar el estado existente en el nuevo back-end? , escriba yes.

  7. Quite el archivo de estado local.

    rm terraform.tfstate*
    
  8. Creación de un plan de ejecución de Terraform. De nuevo, siga las convenciones de nomenclatura predeterminadas. Por ejemplo:

    terraform plan                                                                    \
                    --var-file=DEMO-EUS2-SAP_LIBRARY.json                             \
                    ../../../sap-automation/deploy/terraform/run/sap_library/
    
  9. Aplique un plan de ejecución de Terraform. Por ejemplo:

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

Implementación de la red virtual de carga de trabajo

A continuación, implemente la red virtual de carga de trabajo de SAP.

  1. Mantenga la sesión iniciada en el implementador en el cliente SSH. O vuelva a iniciar sesión.

  2. Cree un directorio de trabajo. Siga las convenciones de nomenclatura predeterminadas.

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/LANDSCAPE/DEMO-EUS2-SAP00-INFRASTRUCTURE; cd $_
    
  3. Cree un archivo de parámetros denominado backend. Para resource_group_name, use el nombre del grupo de recursos donde se encuentra la cuenta de almacenamiento con los archivos de estado de Terraform (.tfstate). Para storage_account_name, reemplace <tfstate_storage_account_name> por el nombre de la cuenta de almacenamiento de la implementación de la biblioteca SAP para archivos .tfstate. Para key, combine el nombre del grupo de recursos del implementador con la extensión .terraform.tfstate. Por ejemplo:

    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. Vuelva a inicializar Terraform.

    terraform init  --backend-config backend                                        \
                    ../../../sap-automation/deploy/terraform/run/sap_landscape/
    
  5. Creación de un plan de ejecución de Terraform. De nuevo, siga las convenciones de nomenclatura predeterminadas. Por ejemplo:

    terraform plan                                                                  \
                --var-file=DEMO-EUS2-SAP00-INFRASTRUCTURE.json                  \
                ../../../sap-automation/deploy/terraform/run/sap_landscape/
    
  6. Aplique un plan de ejecución de Terraform. Por ejemplo:

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

Unidad de implementación de SAP

A continuación, configure la unidad de implementación de SAP.

  1. Mantenga la sesión iniciada en el implementador en el cliente SSH. O vuelva a iniciar sesión.

  2. Cree un directorio de trabajo. Siga las convenciones de nomenclatura predeterminadas.

    mkdir -p ~/Azure_SAP_Automated_Deployment/WORKSPACES/SYSTEM/DEMO-EUS2-SAP00-X00; cd $_
    
  3. Cree otro archivo de parámetros denominado backend. Para resource_group_name, use el nombre del grupo de recursos donde se encuentra la cuenta de almacenamiento con los archivos de estado de Terraform (.tfstate). Para storage_account_name, reemplace <tfstate_storage_account_name> por el nombre de la cuenta de almacenamiento de la implementación de la biblioteca SAP para archivos .tfstate. Para key, combine el nombre del grupo de recursos del implementador con la extensión .terraform.tfstate. Por ejemplo:

    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. Cree un archivo de parámetros JSON con parámetros de entrada como se muestra a continuación. Asegúrese de reemplazar los valores de ejemplo por sus propios valores.

    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. Vuelva a inicializar Terraform.

    terraform init  --backend-config backend                                        \
                    ../../../sap-automation/deploy/terraform/run/sap_system/
    
    
  6. Creación de un plan de ejecución de Terraform. De nuevo, siga las convenciones de nomenclatura predeterminadas. Por ejemplo:

    terraform plan                                                                  \
                    --var-file=DEMO-EUS2-SAP00-X00.json                             \
                    ../../../sap-automation/deploy/terraform/run/sap_system/
    
  7. Aplique un plan de ejecución de Terraform. Por ejemplo:

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

Configuración de Ansible

Establezca la configuración mediante la ejecución de cuadernos de estrategias de Ansible. Estos cuadernos de estrategias se encuentran en el repositorio del marco de automatización en /sap-automation/deploy/ansible.

Nombre de archivo Descripción
playbook_01_os_base_config.yaml Configuración del sistema operativo (SO) base
playbook_02_os_sap_specific_config.yaml Configuración del sistema operativo específico de SAP
playbook_03_bom_processing.yaml Descarga de software de procesamiento de listas de materiales (BOM) de SAP
playbook_04a_sap_scs_install.yaml Instalación de los servicios centrales de SAP (SCS)
playbook_05a_hana_db_install.yaml Instalación de la base de datos de SAP HANA
playbook_06a_sap_dbload.yaml Cargador de bases de datos
playbook_06b_sap_pas_install.yaml Instalación del servidor de aplicaciones principal (PAS) de SAP
playbook_06c_sap_app_install.yaml Instalación del servidor de aplicaciones de SAP
playbook_06d_sap_web_install.yaml Instalación del distribuidor web de SAP
playbook_06_00_00_pacemaker.yaml Configuración del clúster de Pacemaker
playbook_06_00_01_pacemaker_scs.yaml Configuración de Pacemaker para SCS
playbook_06_00_03_pacemaker_hana.yaml Configuración de Pacemaker para la base de datos de SAP HANA

Para ejecutar un cuaderno de estrategias, o varios, use el comando ansible-playbook como se muestra a continuación. Asegúrese de cambiar todos los valores de marcador de posición por su propia información:

  • Cambie <your-sapbits-path> a la ruta de acceso a la cuenta de almacenamiento de la biblioteca SAP sapbits.
  • Cambie <azure-admin> a su nombre de usuario de administrador de Azure.
  • Cambie <ssh-key> a la clave SSH privada que desea usar.
  • Cambie otros valores en --extra-vars según sea necesario para la configuración.

Si experimenta problemas, asegúrese de que ha descargado el software de SAP en su entorno de 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

Pasos siguientes