Tutorial: Utilizar el marco de automatización de implementación de SAP a escala empresarial

Artículo
01/29/2024

En este tutorial se muestra cómo realizar implementaciones mediante el marco de automatización de implementación de SAP. En este ejemplo se Azure Cloud Shell para implementar la infraestructura del plano de control. La máquina virtual (VM) del implementador crea la infraestructura restante y las configuraciones de SAP HANA.

En este tutorial se realizan las siguientes tareas:

Implementar el plano de control (infraestructura y biblioteca del implementador).
Implementar la zona de carga de trabajo (landscape y system).
Descargar o cargar la lista de materiales.
Configure los valores estándar y específicos de SAP del sistema operativo.
Instalar la base de datos de HANA.
Instale el servidor de servicios centrales de SAP (SCS).
Cargar la base de datos de HANA.
Instalar el servidor de aplicaciones principal.

La implementación de SAP en Azure con el marco de automatización consta de tres pasos principales:

Preparar la región. Implementa componentes para admitir el marco de automatización de SAP en una región de Azure especificada. En este paso, hará lo siguiente:
1. Crear el entorno de implementación.
2. Crear almacenamiento compartido para archivos de estado de Terraform.
3. Crear almacenamiento compartido para medios de instalación de SAP.
Preparar la zona de carga de trabajo. Implemente los componentes de la zona de cargas de trabajo, como la red virtual y los almacenes de claves.
Implemente el sistema. Implemente la infraestructura para el sistema SAP.

Hay varios flujos de trabajo en el proceso de automatización de una implementación. Para facilitar la implementación, este tutorial se centra en un flujo de trabajo. Puede implementar este flujo de trabajo, el entorno independiente de SAP S4 HANA, mediante Bash. Este tutorial se describe la jerarquía general y las distintas fases de implementación.

Introducción al entorno

El marco de automatización de implementación de SAP tiene dos componentes principales:

La infraestructura de implementación (plano de control)
La infraestructura de SAP (carga de trabajo de SAP)

En el diagrama siguiente se muestra la dependencia entre el plano de control y el plano de aplicación.

Diagram that shows the DevOps tutorial infrastructure design.

El marco usa Terraform para la implementación de la infraestructura, y Ansible para la configuración del sistema operativo y de la aplicación. En el diagrama siguiente se muestra la separación lógica del plano de control y la zona de cargas de trabajo.

Diagram that shows the SAP Deployment Automation Framework environment.

Zona de administración

La zona de administración contiene la infraestructura del plano de control desde la que se implementan otros entornos. Una vez que se ha implementado la zona de administración, pocas veces, si es que alguna, tendrá que volver a implementarla.

Diagram that shows the control plane.

El implementador es el motor de ejecución del marco de automatización de SAP. Esta máquina virtual preconfigurada se usa para ejecutar comandos de Terraform y Ansible.

Library de SAP proporciona el almacenamiento persistente para los archivos de estado de Terraform y los medios de instalación de SAP descargados para el plano de control.

Configure el implementador y la biblioteca en un archivo de variables .tfvars de Terraform. Para más información, consulte Configuración del plano de control.

Zona de cargas de trabajo

Normalmente, una aplicación de SAP tiene varios niveles de implementación. Por ejemplo, puede tener los niveles de desarrollo, control de calidad y producción. El marco de automatización de implementación de SAP llama a estos niveles zonas de cargas de trabajo.

Diagram that shows the workload zone.

La zona de cargas de trabajo de SAP contiene los componentes de red y compartidos de las VM de SAP. Estos componentes incluyen tablas de rutas, grupos de seguridad de red y redes virtuales. Landscape ofrece la oportunidad de dividir las implementaciones en distintos entornos. Para más información, consulte Configuración de la zona de cargas de trabajo.

La implementación del sistema consta de las máquinas virtuales para ejecutar la aplicación de SAP, incluidos los niveles web, de aplicación y de base de datos. Para más información, consulte Configuración del sistema SAP.

Requisitos previos

El repositorio del marco de automatización de implementaciones de SAP está disponible en GitHub.

Debe implementar Azure Bastion o usar un cliente de Secure Shell (SSH) para conectarse al implementador. Use cualquier cliente SSH con el que se sienta cómodo.

Revisión de la cuota de suscripción de Azure

Asegúrese de que la suscripción a Azure tenga una oferta básica suficiente para las SKU de la familia DdSV4 y EdsV4 en la región elegida. Unos 50 núcleos disponibles para cada familia de VM deberían bastar.

Cuenta de S-User para la descarga del software de SAP

Se requiere una cuenta de usuario de SAP válida (cuenta de SAP-User o S-User) con privilegios de descarga de software para descargar el software de SAP.

Configuración de Cloud Shell

Vaya a Azure Cloud Shell.
Inicie sesión en la cuenta de Azure.
```
az login
```
Autentique el inicio de sesión. No cierre la ventana hasta que se le pida.

Valide la suscripción activa y registre el identificador de la suscripción:

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

az account list --output=table | grep True

Si es necesario, cambie la suscripción activa.

az account set --subscription <Subscription ID>

Valide que la suscripción activa ha cambiado.

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

De manera opcional, quite todos los artefactos de implementación. Use este comando cuando desee eliminar todos los restos de artefactos de implementación anteriores.
```
cd ~

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

Cree la carpeta de implementación y clone el repositorio.

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

También puede validar las versiones de Terraform y de la CLI de Azure disponibles en la instancia del Cloud Shell.
```
./sap-automation/deploy/scripts/helpers/check_workstation.sh
```
Para ejecutar el marco de automatización, actualice a las siguientes versiones:
- az versión 2.5.0 o posterior.
- terraform versión 1.5 o posterior. Actualice siguiendo las instrucciones de Terraform según sea necesario.

Creación de una entidad de servicio

El marco de automatización de implementaciones de SAP usa entidades de servicio para la implementación. Cree una entidad de servicio para la implementación del plano de control. Asegúrese de usar una cuenta con permisos para crear entidades de servicio.

Cuando elija un nombre para la entidad de servicio, asegúrese de que el nombre sea único dentro del inquilino de Azure.

Conceda permisos de colaborador y administrador de acceso de usuario a la entidad de servicio.

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"

Revise el resultado. Por ejemplo:

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

Copie los detalles de la salida. Asegúrate de guardar los valores de appId, password y Tenant.

La salida se asigna a los parámetros siguientes. Estos parámetros se usan en pasos posteriores, con comandos de automatización.

Nombre del parámetro de entrada Nombre de salida

spn_id appId

spn_secret password

tenant_id tenant

Nombre del parámetro de entrada	Nombre de salida
`spn_id`	`appId`
`spn_secret`	`password`
`tenant_id`	`tenant`

Opcionalmente, asigne el rol Administrador de acceso de usuario a la entidad de servicio.

export appId="<appId>"

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

Importante

Si no asigna el rol Administrador de acceso de usuario a la entidad de servicio, no puede asignar permisos mediante la automatización.

Configuración de las credenciales de la aplicación web del plano de control

Como parte del plano de control del marco de automatización de SAP, es posible crear opcionalmente una aplicación web interactiva que ayude a crear los archivos de configuración necesarios.

Screenshot that shows the web app front page.

Crear un registro de aplicación

Si desea utilizar la aplicación web, primero debe crear un registro de aplicación con fines de autenticación. Abra Cloud Shell y ejecute los comandos siguientes:

Reemplace LAB por el entorno, según sea necesario.

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:

Asegúrese de que haya iniciado sesión con una cuenta de usuario que tenga los permisos necesarios para crear registros de aplicaciones. Para obtener más información sobre los registros de aplicaciones, consulte Crear un registro de aplicación.

Copie los detalles de la salida. Asegúrate de guardar los valores de App registration ID y App registration password.

La salida se asigna a los parámetros siguientes. Estos parámetros se usan en pasos posteriores, con comandos de automatización.

Nombre del parámetro de entrada	Nombre de salida
`app_registration_app_id`	`App registration ID`
`webapp_client_secret`	`App registration password`

Visualización de los archivos de configuración

Abra Visual Studio Code desde Cloud Shell.

cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
code .

Expanda el directorio WORKSPACES. Hay seis subcarpetas: CONFIGURATION, DEPLOYER, LANDSCAPE, LIBRARY, SYSTEM y BOMS. Expanda cada una de estas carpetas para buscar archivos de configuración de implementación regional.

Busque los archivos de variables de Terraform en la subcarpeta adecuada. Por ejemplo, el archivo de variables de Terraform DEPLOYER podría tener el siguiente aspecto:

# 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

Anote las ubicaciones de los archivos de variables de Terraform para futuras modificaciones durante la implementación.

Busque los archivos de variables de Terraform de la biblioteca SAP en la subcarpeta adecuada. Por ejemplo, el archivo de variables de Terraform LIBRARY podría tener el siguiente aspecto:

# 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

Anote las ubicaciones de los archivos de variables de Terraform para futuras modificaciones durante la implementación.

Importante

Asegúrese de que dns_label coincida con la instancia del DNS privado de Azure.

Implementación del plano de control

Use el script deploy_controlplane.sh para implementar el implementador y la biblioteca. Estas piezas de implementación componen el plano de control de un área de automatización elegida.

La implementación pasa por ciclos de implementación de la infraestructura, actualización del estado y carga de los archivos de estado de Terraform en la cuenta de almacenamiento de biblioteca. Todos estos pasos están empaquetados en un único script de implementación. El script necesita la ubicación del archivo de configuración para el implementador y la biblioteca, y algunos otros parámetros.

Por ejemplo, elija Oeste de Europa como ubicación de implementación con el nombre de cuatro caracteres SECE, tal y como se describió anteriormente. El archivo de configuración de Deployer de ejemplo LAB-SECE-DEP05-INFRASTRUCTURE.tfvars se encuentra en carpeta ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/DEPLOYER/LAB-SECE-DEP05-INFRASTRUCTURE.

El archivo de configuración de SAP Library de ejemplo LAB-SECE-SAP_LIBRARY.tfvars se encuentra en carpeta ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES/LIBRARY/LAB-SECE-SAP_LIBRARY.

Establezca las variables de entorno de la entidad de servicio:
```
export ARM_SUBSCRIPTION_ID="<subscriptionId>"
export       ARM_CLIENT_ID="<appId>"
export   ARM_CLIENT_SECRET="<password>"
export       ARM_TENANT_ID="<tenantId>"
```
Si se ejecuta el script desde una estación de trabajo que no forma parte de la red de implementación o desde Cloud Shell, se podrá usar el siguiente comando para establecer la variable de entorno para permitir la conectividad desde la dirección IP:
```
export TF_VAR_Agent_IP=<your-public-ip-address>
```
Si se va a implementar la aplicación web de configuración, también se deberán establecer las siguientes variables de entorno:
```
export TF_VAR_app_registration_app_id=<appRegistrationId>
export    TF_VAR_webapp_client_secret=<appRegistrationPassword>
export                  TF_use_webapp=true
```

Cree el implementador y la biblioteca de SAP, y agregue los detalles de la entidad de servicio al almacén de claves de la implementación utilizando 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}"

Si tiene problemas de autenticación, ejecute az logout para cerrar la sesión y borrar token-cache. A continuación, ejecute az login para volver a autenticarse.

Espere a que el marco de automatización ejecute las operaciones de Terraform plan y apply.

La implementación del implementador puede tardar unos 15 a 20 minutos.

Debe tener en cuenta algunos valores para los próximos pasos. Busque este bloque de texto en la salida:

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

Vaya a Azure Portal.

Seleccione Grupos de recursos. Busque nuevos grupos de recursos para la infraestructura del implementador y la biblioteca. Por ejemplo, podría ver LAB-[region]-DEP05-INFRASTRUCTURE y LAB-[region]-SAP_LIBRARY.

Aquí se muestra el contenido de los grupos de recursos del implementador y la biblioteca de SAP.

El archivo de estado de Terraform está ahora en la cuenta de almacenamiento cuyo nombre contiene tfstate. La cuenta de almacenamiento tiene un contenedor denominado tfstate con los archivos de estado de implementador y biblioteca. Aquí se muestra qué incluye el contenedor tfstate después de una implementación correcta del plano de control.

Problemas comunes y soluciones

Estas son algunas sugerencias de solución de problemas:

Si recibe el siguiente error durante la creación del módulo de implementador, asegúrese de que está en el directorio WORKSPACES al ejecutar el script:
```
Incorrect parameter file.
The file must contain the environment attribute!!
```
El siguiente error es transitorio. Vuelva a ejecutar el mismo comando, deploy_controlplane.sh.
```
Error: file provisioner error
..
timeout - last error: dial tcp
```
Si tiene problemas de autenticación directamente después de ejecutar el script deploy_controlplane.sh, ejecute este comando:
```
az logout

az login
```

Conexión con la VM del implementador

Una vez implementado el plano de control, el estado de Terraform se almacena utilizando el back-end remoto azurerm. Todos los secretos para conectarse a la VM del implementador están disponibles en un almacén de claves en el grupo de recursos del implementador.

Para conectarse a la VM del implementador:

Inicie sesión en Azure Portal.
Busque o seleccione Almacenes de claves.
En la página Almacén de claves, busque el almacén de claves del implementador. El nombre empieza por LAB[REGION]DEP05user. Si es necesario, filtre por Grupo de recursos o Ubicación.
En la sección Configuración en el panel izquierdo, seleccione Secretos.
Busque y seleccione el secreto que contiene sshkey. Es posible que tenga este aspecto: LAB-[REGION]-DEP05-sshkey.
En la página del secreto, seleccione la versión actual. A continuación, copie el valor secreto.
Abra un editor de texto sin formato. Copie el valor secreto.
Guarde el archivo donde se mantienen las claves SSH. Por ejemplo, use C:\\Users\\<your-username>\\.ssh.
Guarde el archivo. Si se le pide Guardar como tipo, seleccione Todos los archivos si SSH no es una opción. Por ejemplo, use deployer.ssh.
Conéctese a la máquina virtual del implementador a través de cualquier cliente SSH, como Visual Studio Code. Use la dirección IP pública que anotó anteriormente y la clave SSH que descargó. Para obtener instrucciones sobre cómo conectarse al implementador mediante Visual Studio Code, consulte Conexión al implementador mediante Visual Studio Code. Si usa PuTTY, convierta primero el archivo de clave SSH mediante PuTTYGen.

Nota:

El nombre de usuario predeterminado es azureadm.

Asegúrese de que el archivo que use para guardar la clave SSH pueda guardar el archivo utilizando el formato correcto, es decir, sin caracteres de retorno de carro (CR). Uso de Visual Studio Code o Bloc de notas++.

Una vez conectado a la máquina virtual del implementador, puede descargar el software de SAP mediante la lista de materiales (L. MAT).

Conexión a la máquina virtual del implementador cuando no se usa una IP pública

En el caso de las implementaciones sin conectividad de IP pública, la conectividad a través de Internet no se permite. En estos casos, puede utilizar un jump box de Azure Bastion o realizar el paso siguiente desde un equipo que tenga conectividad con la red virtual de Azure.

En el ejemplo siguiente se usa Azure Bastion.

Para conectarse al implementador:

Inicie sesión en Azure Portal.
Vaya al grupo de recursos que contiene la VM del implementador.
Conéctese a la VM utilizando Azure Bastion.
El nombre de usuario predeterminado es azureadm.
Seleccione Clave privada SSH de Azure Key Vault.
Seleccione la suscripción que contiene el plano de control.
Seleccione el almacén de claves del implementador.
En la lista de secretos, seleccione el secreto que termina en -sshkey.
Conecte a la máquina virtual.

El resto de las tareas deben ejecutarse en el implementador.

Proteger el plano de control

El plano de control es la parte más crítica del marco de automatización de SAP. Por lo tanto, es importante protegerlo. Los pasos siguientes le ayudarán a proteger el plano de control.

Debería actualizar el archivo tfvars del plano de control para habilitar puntos de conexión privados, y bloquear el acceso público a las cuentas de almacenamiento y los almacenes de claves.

Para copiar los archivos de configuración del plano de control en la máquina virtual del implementador, puede usar el script de sync_deployer.sh. Inicie sesión en la máquina virtual del implementador y actualice el siguiente comando para usar el nombre de la cuenta de almacenamiento de estado de Terraform. A continuación, ejecute el siguiente 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 los archivos de configuración tfvars desde la cuenta de almacenamiento de la biblioteca de SAP hasta la máquina virtual del implementador.

Cambie los archivos de configuración del plano de control de la siguiente manera:


    # 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

Vuelva a ejecutar la implementación para aplicar los cambios. Actualice el nombre de la cuenta de almacenamiento y del almacén de claves en el script.


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

Cree el implementador y la biblioteca de 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}"

Implementar la aplicación web

Puede implementar la aplicación web con el siguiente 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

Recopilación de información de la zona de cargas de trabajo

Recopile la siguiente información en un editor de texto. Esta información siguiente se recopiló al final de la fase de "Implementación del plano de control".
1. Nombre de la cuenta de almacenamiento de los archivos de estado de Terraform en el grupo de recursos de biblioteca:
  - Siguiendo con el ejemplo anterior, el grupo de recursos es LAB-SECE-SAP_LIBRARY.
  - El nombre de la cuenta de almacenamiento contiene labsecetfstate.
2. El nombre del almacén de claves del grupo de recursos del implementador:
  - Siguiendo con el ejemplo anterior, el grupo de recursos es LAB-SECE-DEP05-INFRASTRUCTURE.
  - El nombre del almacén de claves contiene LABSECEDEP05user.
3. La dirección IP pública de la VM del implementador. Vaya al grupo de recursos Deployer, abra la VM del implementador y copie la dirección IP pública.
Debe recopilar la información siguiente:
1. El nombre del archivo de estado del implementador se encuentra en el grupo de recursos de la biblioteca:
  - Seleccione Grupo de recursos de biblioteca>Cuenta de almacenamiento de estado> deContenedores>tfstate. Copie el nombre del archivo de estado del implementador.
  - Siguiendo con el ejemplo anterior, el nombre del blob es LAB-SECE-DEP05-INFRASTRUCTURE.terraform.tfstate.

Si es necesario, registre la entidad de servicio. En este tutorial, este paso no es necesario.

La primera vez que se crea una instancia de un entorno, debe registrarse una entidad de servicio. En este tutorial, el plano de control está en el entorno LAB y la zona de carga de trabajo también está en LAB. Por este motivo, se debe registrar una entidad de servicio para el entorno LAB.

export ARM_SUBSCRIPTION_ID="<subscriptionId>"
export       ARM_CLIENT_ID="<appID>"
export   ARM_CLIENT_SECRET="<password>"
export       ARM_TENANT_ID="<tenant>"
export           key_vault="<vaultName>"
export            env_code="LAB"
export         region_code="SECE"

export SAP_AUTOMATION_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/sap-automation"
export         CONFIG_REPO_PATH="${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES"


${SAP_AUTOMATION_REPO_PATH}/deploy/scripts/set_secrets.sh \
    --environment "${env_code}"                           \
    --region "${region_code}"                             \
    --vault "${key_vault}"                                \
    --subscription "${ARM_SUBSCRIPTION_ID}"               \
    --spn_id "${ARM_CLIENT_ID}"                           \
    --spn_secret "${ARM_CLIENT_SECRET}"                   \
    --tenant_id "${ARM_TENANT_ID}"

Preparación de la implementación de la zona de cargas de trabajo

Conéctese a la VM del implementador para los pasos siguientes. Ahora allí hay una copia del repositorio.

Implementación de la zona de cargas de trabajo

Use el script install_workloadzone para implementar la zona de cargas de trabajo de SAP.

En la VM del implementador, vaya a la carpeta Azure_SAP_Automated_Deployment.

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

Opcionalmente, abra el archivo de configuración de la zona de cargas de trabajo y, si es necesario, cambie el nombre lógico de red para que coincida con el nombre de red.
Inicie la implementación de la zona de cargas de trabajo. Los detalles que ha recopilado anteriormente son necesarios aquí:
- Nombre del archivo tfstate del implementador (que se encuentra en el contenedor tfstate)
- Nombre de la cuenta de almacenamiento tfstate
- Nombre del almacén de claves del implementador


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

La implementación de la zona de cargas de trabajo debe iniciarse automáticamente.

Espere a que finalice la implementación. El nuevo grupo de recursos aparece en Azure Portal.

Preparación para implementar la infraestructura del sistema SAP

Conéctese a la VM del implementador para los pasos siguientes. Ahora allí hay una copia del repositorio.

Vaya a la carpeta WORKSPACES/SYSTEM y copie los archivos de configuración de ejemplo para usar desde el repositorio.

Implementación de la infraestructura del sistema SAP

Una vez finalizada la zona de cargas de trabajo, puede implementar los recursos de infraestructura del sistema SAP. El sistema SAP crea las VM y los componentes auxiliares para la aplicación de SAP. Use el script installer.sh para implementar el sistema SAP.

El sistema SAP implementa:

El nivel de base de datos, que implementa las VM de base de datos y sus discos, y una instancia de Azure Standard Load Balancer. En este nivel puede ejecutar bases de datos de HANA o bases de datos de AnyDB.
El nivel de SCS, que implementa un número de VM definido por el cliente, y una instancia de Azure Standard Load Balancer.
El nivel de aplicación, que implementa las VM y sus discos.
El nivel de Web Dispatcher.

Implemente el 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

Compruebe que el grupo de recursos del sistema ahora esté en Azure Portal.

Obtención de software de SAP mediante la lista de materiales

El marco de automatización le proporciona herramientas para descargar software de SAP mediante la lista de materiales (L. MAT) de SAP. El software se descarga en la biblioteca de SAP, que actúa como archivo de todos los medios necesarios para implementar SAP.

La lista de materiales (BOM) de SAP emula a SAP Maintenance Planner. Hay identificadores de producto pertinentes y un conjunto de direcciones URL de descarga.

Un extracto de ejemplo de un archivo BOM tiene el siguiente aspecto:


---
name:    'S41909SPS03_v0010'
target:  'S/4 HANA 1909 SPS 03'
version: 7

product_ids:
  dbl:       NW_ABAP_DB:S4HANA1909.CORE.HDB.ABAP
  scs:       NW_ABAP_ASCS:S4HANA1909.CORE.HDB.ABAP
  scs_ha:    NW_ABAP_ASCS:S4HANA1909.CORE.HDB.ABAPHA
  pas:       NW_ABAP_CI:S4HANA1909.CORE.HDB.ABAP
  pas_ha:    NW_ABAP_CI:S4HANA1909.CORE.HDB.ABAPHA
  app:       NW_DI:S4HANA1909.CORE.HDB.PD
  app_ha:    NW_DI:S4HANA1909.CORE.HDB.ABAPHA
  web:       NW_Webdispatcher:NW750.IND.PD
  ers:       NW_ERS:S4HANA1909.CORE.HDB.ABAP
  ers_ha:    NW_ERS:S4HANA1909.CORE.HDB.ABAPHA

materials:
  dependencies:
    - name:     HANA_2_00_055_v0005ms

  media:
    # SAPCAR 7.22
    - name:         SAPCAR
      archive:      SAPCAR_1010-70006178.EXE
      checksum:     dff45f8df953ef09dc560ea2689e53d46a14788d5d184834bb56544d342d7b
      filename:     SAPCAR
      permissions:  '0755'
      url:          https://softwaredownloads.sap.com/file/0020000002208852020

    # Kernel
    - name:         "Kernel Part I ; OS: Linux on x86_64 64bit ; DB: Database independent"

Para esta configuración de ejemplo, el grupo de recursos es LAB-SECE-DEP05-INFRASTRUCTURE. El nombre del almacén de claves del implementador incluye LABSECEDEP05user en el nombre. Esta información se usa para configurar los secretos del almacén de claves del implementador.

Conéctese a la VM del implementador para los pasos siguientes. Ahora allí hay una copia del repositorio.
Agregue un secreto con el nombre de usuario de la cuenta de usuario de SAP. Reemplace <vaultName> por el nombre del almacén de claves del implementador. Además, reemplace <sap-username> por el nombre de usuario de SAP.
```
export key_vault=<vaultName>
    sap_username=<sap-username>

az keyvault secret set --name "S-Username" --vault-name $key_vault --value "${sap_username}";
```
Agregue un secreto con la contraseña de la cuenta de usuario de SAP. Reemplace <vaultName> por el nombre del almacén de claves del implementador y reemplace <sap-password> por la contraseña de SAP.

Nota:

El uso de comillas simples cuando se establece sap_user_password es importante. De lo contrario, el uso de caracteres especiales en la contraseña puede provocar resultados impredecibles.
```
sap_user_password='<sap-password>'

az keyvault secret set --name "S-Password" --vault-name "${key_vault}" --value="${sap_user_password}";
```
Configure el archivo de parámetros de SAP para el proceso de descarga. Luego, descargue el software de SAP mediante cuadernos de estrategias de Ansible. Ejecute los comandos siguientes:
```
cd ${HOME}/Azure_SAP_Automated_Deployment/WORKSPACES
mkdir BOMS
cd BOMS

vi sap-parameters.yaml
```
Actualice bom_base_name con el nombre BOM. Reemplace <Deployer KeyVault Name> por el nombre del almacén de claves de Azure del grupo de recursos del implementador.

El archivo debe tener una apariencia similar a la configuración de ejemplo siguiente:
```
bom_base_name:                 S42022SPS00_v0001ms
deployer_kv_name:              <vaultName>
BOM_directory:                 ${HOME}/Azure_SAP_Automated_Deployment/samples/SAP
```
Ejecute el cuaderno de estrategias de Ansible para descargar el software. Una forma de ejecutar los cuadernos de estrategias es usar el menú Descargador. Ejecute el script download_menu.
```
${HOME}/Azure_SAP_Automated_Deployment/sap-automation/deploy/ansible/download_menu.sh
```

Seleccione el guion de procedimientos que desea ejecutar.

1) BoM Downloader
3) Quit
Please select playbook:

Seleccione el guion 1) BoM Downloader para descargar el software de SAP descrito en el archivo BOM en la cuenta de almacenamiento. Compruebe que el contenedor sapbits tiene todos los medios para la instalación.

Puede ejecutar el cuaderno de estrategias mediante el menú de configuración o directamente desde la línea de comandos.


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

Si lo desea, también puede pasar las credenciales de usuario de 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

Instalación de la aplicación de SAP

La instalación de la aplicación de SAP se produce a través de guiones de procedimientos de Ansible.

Vaya a la carpeta de implementación del sistema.

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

Asegúrese de que tiene los siguientes archivos en las carpetas actuales: sap-parameters.yaml y L00_host.yaml.

En el caso de un sistema SAP S/4HANA independiente, hay ocho guiones de procedimientos para ejecutarse en secuencia. Una forma de ejecutar los cuadernos de estrategias es usar el menú Configuración.

Ejecute el script configuration_menu.

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

Elija los cuadernos de estrategias que se van a ejecutar.

Cuaderno de estrategias: configuración del sistema operativo base

Este cuaderno de estrategias realiza la configuración genérica del sistema operativo en todas las máquinas, lo que incluye la configuración de repositorios de software, paquetes y servicios.