Ejercicio: Implementación del patrón de implementación azul-verde

En Creación de una canalización de varias fases mediante Azure Pipelines, ha creado una canalización de implementación básica que implementa una aplicación web en Azure App Service en estas fases: Desarrollo, Prueba y Ensayo.

Aquí, agregará ese flujo de trabajo mediante la aplicación del patrón de implementación azul-verde durante la fase de Almacenamiento provisional.

Para ello, haremos lo siguiente:

Adición de una ranura de implementación

Aquí agregas un slot de implementación a la instancia de App Service que corresponde a Staging.

De forma predeterminada, cada instancia de App Service proporciona una ranura predeterminada, denominada producción. Ha realizado la implementación en la ranura de producción al configurar la canalización en la sección anterior.

Una instancia de App Service puede tener varias ranuras. Aquí se agrega una segunda ranura de implementación a la instancia de App Service que corresponde al almacenamiento provisional. La ranura de implementación se denomina de intercambio.

Para agregar la ranura:

1. Vaya a Azure Portal e inicie sesión.

2. En el menú, seleccione Cloud Shell. Cuando se le solicite, seleccione la experiencia de Bash .

3. Ejecute el siguiente comando para obtener el nombre de la instancia de App Service que corresponde al almacenamiento provisional y almacenar el resultado en una variable de Bash denominada staging.

   staging=$(az webapp list \
     --resource-group tailspin-space-game-rg \
     --query "[?contains(@.name, 'tailspin-space-game-web-staging')].{name: name}" \
     --output tsv)
   

   El --query argumento usa JMESPath, que es un lenguaje de consulta para JSON. El argumento selecciona la instancia de App Service cuyo campo name contiene "tailspin-space-game-web-staging".

4. Imprima la staging variable para comprobar que obtiene el nombre correcto.

   echo $staging
   

   A continuación, presentamos un ejemplo de la salida:

   tailspin-space-game-web-staging-1234
   

5. Ejecute el siguiente comando para agregar una ranura denominada swap al entorno de ensayo .

   az webapp deployment slot create \
     --name $staging \
     --resource-group tailspin-space-game-rg \
     --slot swap
   

6. Ejecute el comando siguiente para mostrar el nombre de host de la ranura de implementación.

   az webapp deployment slot list \
       --name $staging \
       --resource-group tailspin-space-game-rg \
       --query [].hostNames \
       --output tsv
   

   El resultado es similar a este resultado:

   tailspin-space-game-web-staging-25391-swap.azurewebsites.net
   

   Anote este nombre de host para más adelante.

7. Como paso opcional, vaya al sitio en un explorador. Ves la página de inicio predeterminada porque aún no has implementado el código en este slot.

   

De forma predeterminada, se puede acceder a una ranura de implementación desde Internet. En la práctica, podría configurar una red virtual de Azure que coloque el espacio de intercambio en una red que no sea enrutable desde Internet, pero a la que solo pueda acceder su equipo. Tu espacio de producción seguiría siendo accesible desde internet.

Intercambio de ranuras de implementación en el almacenamiento provisional

Aquí se usa la tarea AzureAppServiceManage@0 para intercambiar ranuras de implementación en el entorno de ensayo .

También puede usar esta tarea para iniciar, detener o eliminar una ranura. O bien, puede usarlo para instalar extensiones de sitio o para habilitar la supervisión continua en App Service.

1. En Visual Studio Code, modifique azure-pipelines.yml mediante este código:

   Sugerencia

   Puede reemplazar todo el archivo o simplemente actualizar el elemento resaltado.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   
   - stage: 'Dev'
     displayName: 'Deploy to the dev environment'
     dependsOn: Build
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: dev
       variables:
       - group: Release
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Test'
     displayName: 'Deploy to the test environment'
     dependsOn: Dev
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: test
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameTest)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Staging'
     displayName: 'Deploy to the staging environment'
     dependsOn: Test
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: staging
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 deployToSlotOrASE: 'true'
                 resourceGroupName: 'tailspin-space-game-rg'
                 slotName: 'swap'
                 appName: '$(WebAppNameStaging)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
             - task: AzureAppServiceManage@0
               displayName: 'Swap deployment slots'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 resourceGroupName: 'tailspin-space-game-rg'
                 webAppName: '$(WebAppNameStaging)'
                 sourceSlot: 'swap'
                 targetSlot: 'production'
                 action: 'Swap Slots'
   

   Tenga en cuenta estos cambios:

   • La AzureWebApp@1 tarea ahora especifica estos valores:
     • deployToSlotOrASE, cuando se establece en true, se implementa en una ranura de implementación existente.
     • resourceGroupName especifica el nombre del grupo de recursos. Este valor es necesario cuando deployToSlotOrASE es true.
     • slotName especifica el nombre de la ranura de implementación. Aquí la implementación se realiza en la ranura denominada de intercambio.
   • La nueva tarea, AzureAppServiceManage@0, intercambia las ranuras de implementación.
     • sourceSlot y targetSlot especifican las ranuras que se van a intercambiar.
     • action especifica la acción que se va a realizar. Recuerda que puedes usar esta tarea para iniciar, parar o eliminar un espacio. Aquí, "Intercambiar ranuras" especifica el intercambio de las ranuras de origen y de destino.

   Esta configuración siempre realiza la implementación en la ranura de intercambio. Después, intercambia las ranuras de producción y de intercambio. El proceso de intercambio garantiza que producción señale a la implementación más reciente.

2. En el terminal integrado, agregue azure-pipelines.yml al índice. Confirme los cambios y, a continuación, inserte la rama en GitHub.

   Sugerencia

   Guarde azure-pipelines.yml antes de ejecutar estos comandos de Git.

   git add azure-pipelines.yml
   git commit -m "Swap deployment slots"
   git push origin blue-green
   

3. En Azure Pipelines, realice el seguimiento de la compilación a lo largo de cada uno de los pasos.

1. Como paso opcional, en un explorador, vaya a la dirección URL que corresponde a cada fase.

   Aunque aún no ha realizado cambios en el sitio web, verá que el sitio web de Space Game se implementó correctamente en cada entorno de App Service.