Usar o Azure Spring Apps CI/CD com ações do GitHub

Configurar o repositório GitHub e autenticar

Você precisa de uma credencial de entidade de serviço do Azure para autorizar a ação de início de sessão no Azure. Para obter uma credencial do Azure, execute os seguintes comandos em sua máquina local:

az login
az ad sp create-for-rbac \
    --role contributor \
    --scopes /subscriptions/<SUBSCRIPTION_ID> \
    --json-auth

Para acessar um grupo de recursos específico, você pode reduzir o escopo:

az ad sp create-for-rbac \
    --role contributor \
    --scopes /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP> \
    --json-auth

O comando deve gerar um objeto JSON:

{
    "clientId": "<GUID>",
    "clientSecret": "<GUID>",
    "subscriptionId": "<GUID>",
    "tenantId": "<GUID>",
    ...
}

Este exemplo utiliza o exemplo steeltoe no GitHub. Fork o repositório, abra a página do repositório no GitHub do fork e selecione o separador Configurações. Abra o menu Segredos e selecione Novo segredo:

Defina o nome secreto para AZURE_CREDENTIALS e seu valor para a cadeia de caracteres JSON que encontrou sob o cabeçalho Configurar o seu repositório GitHub e autenticar.

Você também pode obter a credencial de logon do Azure do Cofre da Chave nas Ações do GitHub, conforme explicado em Autenticar o Azure Spring com o Cofre da Chave nas Ações do GitHub.

Instância do serviço de provisão

Para provisionar sua instância de serviço do Azure Spring Apps, execute os seguintes comandos usando a CLI do Azure.

az extension add --name spring
az group create \
    --name <resource-group-name> \
    --location eastus
az spring create \
    --resource-group <resource-group-name> \
    --name <service-instance-name>
az spring config-server git set \
    --name <service-instance-name> \
    --uri https://github.com/Azure-Samples/azure-spring-apps-samples \
    --label main \
    --search-paths steeltoe-sample/config

Criar o fluxo de trabalho

O fluxo de trabalho é definido usando as seguintes opções.

Prepare-se para a implantação com a CLI do Azure

Atualmente, o comando az spring app create não é idempotente. Depois de executá-lo uma vez, você receberá um erro se executar o mesmo comando novamente. Recomendamos esse fluxo de trabalho em aplicativos e instâncias existentes do Azure Spring Apps.

Use os seguintes comandos da CLI do Azure para preparação:

az config set defaults.group=<service-group-name>
az config set defaults.spring=<service-instance-name>
az spring app create --name planet-weather-provider
az spring app create --name solar-system-weather

Implantar diretamente com a CLI do Azure

Crie o arquivo .github/workflows/main.yml no repositório com o seguinte conteúdo. Substitua <your resource group name> e <your service name> com os valores corretos.

name: Steeltoe-CD

# Controls when the action runs. Triggers the workflow on push or pull request
# events but only for the main branch
on:
  push:
    branches: [ main]

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "build"
  build:
    # The type of runner that the job runs on
    runs-on: ubuntu-latest
    env:
      working-directory: ./steeltoe-sample
      resource-group-name: <your resource group name>
      service-name: <your service name>

    # Supported .NET Core version matrix.
    strategy:
      matrix:
        dotnet: [ '3.1.x' ]

    # Steps represent a sequence of tasks that is executed as part of the job
    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - uses: actions/checkout@v2

      # Set up .NET Core 3.1 SDK
      - uses: actions/setup-dotnet@v1
        with:
          dotnet-version: ${{ matrix.dotnet }}

      # Set credential for az login
      - uses: azure/login@v1.1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: install Azure CLI extension
        run: |
          az extension add --name spring --yes

      - name: Build and package planet-weather-provider app
        working-directory: ${{env.working-directory}}/src/planet-weather-provider
        run: |
          dotnet publish
          az spring app deploy -n planet-weather-provider --runtime-version NetCore_31 --main-entry Microsoft.Azure.SpringCloud.Sample.PlanetWeatherProvider.dll --artifact-path ./publish-deploy-planet.zip -s ${{ env.service-name }} -g ${{ env.resource-group-name }}
      - name: Build solar-system-weather app
        working-directory: ${{env.working-directory}}/src/solar-system-weather
        run: |
          dotnet publish
          az spring app deploy -n solar-system-weather --runtime-version NetCore_31 --main-entry Microsoft.Azure.SpringCloud.Sample.SolarSystemWeather.dll --artifact-path ./publish-deploy-solar.zip -s ${{ env.service-name }} -g ${{ env.resource-group-name }}

Configurar o repositório GitHub e autenticar

Você precisa de uma credencial de entidade de serviço do Azure para autorizar a ação de início de sessão no Azure. Para obter uma credencial do Azure, execute os seguintes comandos em sua máquina local:

az login
az ad sp create-for-rbac \
    --role contributor \
    --scopes /subscriptions/<SUBSCRIPTION_ID> \
    --json-auth

Para acessar um grupo de recursos específico, você pode reduzir o escopo:

az ad sp create-for-rbac \
    --role contributor \
    --scopes /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP> \
    --json-auth

O comando deve gerar um objeto JSON:

{
    "clientId": "<GUID>",
    "clientSecret": "<GUID>",
    "subscriptionId": "<GUID>",
    "tenantId": "<GUID>",
    ...
}

Este exemplo usa o exemplo PiggyMetrics no GitHub. Faça fork da amostra, desmarque Copiar somente a ramificação do Azure, abra a página do repositório no GitHub e selecione o separador Configurações. Abra o menu Segredos e selecione Adicionar um novo segredo:

Defina o nome secreto para AZURE_CREDENTIALS e o seu valor para a cadeia de caracteres JSON que você encontrou sob o cabeçalho Configurar o seu repositório GitHub e autenticar.

Você também pode obter a credencial de logon do Azure do Cofre da Chave nas Ações do GitHub, conforme explicado em Autenticar o Azure Spring com o Cofre da Chave nas Ações do GitHub.

Instância de serviço de provisionamento

Para provisionar sua instância de serviço do Azure Spring Apps, execute os seguintes comandos usando a CLI do Azure.

az extension add --name spring
az group create --location eastus --name <resource group name>
az spring create -n <service instance name> -g <resource group name>
az spring config-server git set -n <service instance name> --uri https://github.com/xxx/piggymetrics --label config

Fluxos de trabalho de exemplo completos

Os exemplos a seguir demonstram cenários de uso comuns.

Deploying

As seções a seguir mostram várias opções para implantar seu aplicativo.

Para a produção

O Azure Spring Apps dá suporte à implantação em implantações com artefatos criados (por exemplo, JAR ou .NET Core ZIP) ou arquivo de código-fonte.

O exemplo a seguir é implantado na implementação padrão de produção no Azure Spring Apps usando um ficheiro JAR gerado pelo Maven. Este exemplo é o único cenário de implantação possível ao usar a SKU básica:

name: AzureSpringApps
on: push
env:
  ASC_PACKAGE_PATH: ${{ github.workspace }}
  AZURE_SUBSCRIPTION: <azure subscription name>

jobs:
  deploy_to_production:
    runs-on: ubuntu-latest
    name: deploy to production with artifact
    steps:
      - name: Checkout GitHub Action
        uses: actions/checkout@v2

      - name: Set up Java 11
        uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '11'

      - name: maven build, clean
        run: |
          mvn clean package

      - name: Login via Azure CLI
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: deploy to production with artifact
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: Deploy
          service-name: <service instance name>
          app-name: <app name>
          use-staging-deployment: false
          package: ${{ env.ASC_PACKAGE_PATH }}/**/*.jar

O exemplo a seguir faz a implementação, usando o código-fonte, na implantação padrão de produção do Azure Spring Apps.

name: AzureSpringApps
on: push
env:
  ASC_PACKAGE_PATH: ${{ github.workspace }}
  AZURE_SUBSCRIPTION: <azure subscription name>

jobs:
  deploy_to_production:
    runs-on: ubuntu-latest
    name: deploy to production with source code
    steps:
      - name: Checkout GitHub Action
        uses: actions/checkout@v2

      - name: Login via Azure CLI
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: deploy to production step with source code
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: deploy
          service-name: <service instance name>
          app-name: <app name>
          use-staging-deployment: false
          package: ${{ env.ASC_PACKAGE_PATH }}

O exemplo a seguir implanta na implantação de produção padrão no Azure Spring Apps usando o código-fonte no plano Enterprise. Você pode especificar qual construtor usar para ações de implantação usando a builder opção.

name: AzureSpringApps
on: push
env:
  ASC_PACKAGE_PATH: ${{ github.workspace }}
  AZURE_SUBSCRIPTION: <azure subscription name>

jobs:
  deploy_to_production:
    runs-on: ubuntu-latest
    name: deploy to production with source code
    steps:
      - name: Checkout GitHub Action
        uses: actions/checkout@v2

      - name: Login via Azure CLI
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: deploy to production step with source code in the Enterprise plan
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: deploy
          service-name: <service instance name>
          app-name: <app name>
          use-staging-deployment: false
          package: ${{ env.ASC_PACKAGE_PATH }}
          builder: <builder>

O exemplo a seguir efetua a implementação na implantação de produção padrão no Azure Spring Apps com uma imagem de contentor existente.

name: AzureSpringApps
on: push
env:
  ASC_PACKAGE_PATH: ${{ github.workspace }}
  AZURE_SUBSCRIPTION: <azure subscription name>

jobs:
  deploy_to_production:
    runs-on: ubuntu-latest
    name: deploy to production with source code
    steps:
      - name: Checkout GitHub Action
        uses: actions/checkout@v2

      - name: Login via Azure CLI
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: Deploy Custom Image
        uses: Azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: deploy
          service-name: <service instance name>
          app-name: <app name>
          deployment-name: <deployment name>
          container-registry: <your container image registry>
          registry-username: ${{ env.REGISTRY_USERNAME }}
          registry-password: ${{ secrets.REGISTRY_PASSWORD }}
          container-image: <your image tag>

Durante a implantação, você pode obter mais funcionalidade usando mais argumentos. Para obter mais informações, consulte a seção Argumentos da Ação do GitHub para implantação no Azure Spring Apps.

Blue-green

Os exemplos a seguir são implantados numa implementação de testes existente. Essa implantação não recebe tráfego de produção até que seja definida como uma implantação de produção. Você pode definir `use-staging-deployment true` para encontrar automaticamente a implantação de staging ou simplesmente alocar um nome de implantação específico. Nós só nos concentramos na spring-apps-deploy ação e deixamos de fora os trabalhos preparatórios no resto do artigo.

# environment preparation configurations omitted
    steps:
      - name: blue green deploy step use-staging-deployment
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: deploy
          service-name: <service instance name>
          app-name: <app name>
          use-staging-deployment: true
          package: ${{ env.ASC_PACKAGE_PATH }}/**/*.jar

# environment preparation configurations omitted
    steps:
      - name: blue green deploy step with deployment-name
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: deploy
          service-name: <service instance name>
          app-name: <app name>
          deployment-name: staging
          package: ${{ env.ASC_PACKAGE_PATH }}/**/*.jar

Para obter mais informações sobre implantações verde-azul, incluindo uma abordagem alternativa, consulte Estratégias de implantação verde-azul.

Definindo a implantação de produção

No exemplo a seguir, a implementação em preparação atual é definida como produção, efetivamente alternando qual implementação recebe o tráfego de produção.

# environment preparation configurations omitted
    steps:
      - name: set production deployment step
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: set-production
          service-name: <service instance name>
          app-name: <app name>
          use-staging-deployment: true

Eliminando uma implantação de teste

A ação Delete Staging Deployment permite eliminar a implementação que não está a receber tráfego de produção. Essa exclusão libera recursos usados por essa implantação e abre espaço para uma nova implantação de preparação:

# environment preparation configurations omitted
    steps:
      - name: Delete staging deployment step
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: delete-staging-deployment
          service-name: <service instance name>
          app-name: <app name>

Criar ou atualizar compilação (somente plano Enterprise)

O exemplo a seguir cria ou atualiza um recurso de compilação no plano Enterprise:

# environment preparation configurations omitted
    steps:
      - name: Create or update build
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: build
          service-name: <service instance name>
          build-name: <build name>
          package: ${{ env.ASC_PACKAGE_PATH }}
          builder: <builder>

Excluir compilação (somente plano Enterprise)

O exemplo a seguir exclui um recurso de compilação no plano Enterprise:

# environment preparation configurations omitted
    steps:
      - name: Delete build
        uses: azure/spring-apps-deploy@v1
        with:
          azure-subscription: ${{ env.AZURE_SUBSCRIPTION }}
          action: delete-build
          service-name: <service instance name>
          build-name: <build name>

Implante com o Maven Plugin

Outra opção é usar o plug-in Maven para implantar o Jar e atualizar as configurações do aplicativo. O comando mvn azure-spring-apps:deploy é idempotente e cria automaticamente Apps, se necessário. Você não precisa criar aplicativos correspondentes com antecedência.

name: AzureSpringApps
on: push

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:

    - uses: actions/checkout@main

    - name: Set up Java 11
      uses: actions/setup-java@v3
      with:
        distribution: 'temurin'
        java-version: '11'

    - name: maven build, clean
      run: |
        mvn clean package -DskipTests

    # Maven plugin can consume this authentication method automatically
    - name: Azure Login
      uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    # Maven deploy, make sure you have correct configurations in your pom.xml
    - name: deploy to Azure Spring Apps using Maven
      run: |
        mvn azure-spring-apps:deploy