Entrega contínua usando o GitHub Actions

Artigo
11/04/2024

Você pode usar o Fluxo de trabalho do GitHub Actions para definir um fluxo de trabalho para compilar e implantar um código automaticamente no aplicativo de funções no Azure Functions.

Um arquivo YAML (.yml) que define a configuração do fluxo de trabalho é mantido no caminho /.github/workflows/ em seu repositório. Essa definição contém as ações e parâmetros que compõem o fluxo de trabalho, que é específico para a linguagem de desenvolvimento de suas funções. Um fluxo de trabalho GitHub Actions para o Functions executa as seguintes tarefas, independentemente da linguagem:

Configurar o ambiente.
Crie o projeto de código.
Implante o pacote em um aplicativo de funções no Azure.

A ação Azure Functions manipula a implantação em um aplicativo de funções existente no Azure.

Você pode criar um arquivo de configuração de fluxo de trabalho para sua implantação manualmente. Você também pode gerar o arquivo de um conjunto de modelos específicos do idioma de uma destas maneiras:

No portal do Azure
Usando a CLI do Azure
No repositório GitHub

Se você não quiser criar seu arquivo YAML manualmente, selecione um método diferente na parte superior do artigo.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
Uma conta do GitHub. Caso ainda não tenha uma, inscreva-se gratuitamente.
Um aplicativo de funções de trabalho hospedado no Azure com um repositório GitHub.

CLI do Azure, ao desenvolver localmente. Você também pode usar a CLI do Azure no Azure Cloud Shell.

Gerar as credenciais de implantação

Como GitHub Actions usa seu perfil de publicação para acessar seu aplicativo de funções durante a implantação, primeiro você precisa obter seu perfil de publicação e armazená-lo com segurança como um segredo do GitHub.

Importante

O perfil de publicação é uma credencial valiosa que permite o acesso aos recursos do Azure. Certifique-se de sempre transportá-lo e armazená-lo com segurança. No GitHub, o perfil de publicação só deve ser armazenado em segredos do GitHub.

Baixar o perfil de publicação

Para baixar o perfil de publicação do seu aplicativo de funções:

No portal do Azure, localize a página do aplicativo de funções, expanda Configurações>Configuração na coluna à esquerda.
Na página Configuração, selecione a guia Configurações gerais e verifique se a opção Credenciais de Publicação de Autenticação Básica SCM está Ativada. Quando essa configuração estiver Desativada, você não poderá usar perfis de publicação, portanto, selecione Ativar e, em seguida, Salvar.
Retorne à página Visão geral do aplicativo de funções e, em seguida, selecione Obter perfil de publicação.
Salve e copie o conteúdo do arquivo.

Adicionar o segredo do GitHub

No GitHub, acesse seu repositório.
Vá para Configurações.
Selecione Segredos e variáveis> Ações.
Selecione Novo segredo de repositório.
Adicione um novo segredo com o nome AZURE_FUNCTIONAPP_PUBLISH_PROFILE e o valor definido para o conteúdo do arquivo de perfil de publicação.
Selecione Adicionar segredo.

O GitHub agora pode se autenticar no seu aplicativo de funções no Azure.

Criar um fluxo de trabalho com base em um modelo

A melhor maneira de criar manualmente uma configuração de fluxo de trabalho é começar a partir do modelo com suporte oficial.

Criar a configuração do fluxo de trabalho no portal

Quando você usa o portal para habilitar GitHub Actions, o Functions cria um arquivo de fluxo de trabalho com base na pilha de aplicativos e o confirma no repositório GitHub no diretório correto.

O portal obtém automaticamente seu perfil de publicação e o adiciona aos segredos do GitHub para seu repositório.

Durante a criação do aplicativo de funções

Você pode começar rapidamente com GitHub Actions por meio da guia Implantação ao criar uma função no portal do Azure. Para adicionar um fluxo de trabalho GitHub Actions ao criar um novo aplicativo de funções:

No portal do Azure, selecione Implantação no fluxo Criar Aplicativo de Funções.
Habilite a Implantação Contínua se quiser que cada atualização de código dispare um push de código para portal do Azure.
Insira sua organização, repositório e branch do GitHub.
Conclua a configuração do aplicativo de funções. Seu repositório GitHub agora inclui um novo arquivo de fluxo de trabalho no /.github/workflows/.

Adicionar a um aplicativo de funções existente

Para adicionar um fluxo de trabalho GitHub Actions a um aplicativo de funções existente:

Navegue até seu aplicativo de funções no portal do Azure e selecione Centro de Implantação.
Em Fonte, selecione GitHub. Se você não vir a mensagem padrão Criando com o GitHub Actions, selecione Alterar provedor, escolha GitHub Actions e selecione OK.
Se você ainda não autorizou o acesso ao GitHub, selecione Autorizar. Forneça as credenciais do GitHub e selecione Entrar. Para autorizar uma conta diferente do GitHub, selecione Alterar conta e entre com outra conta.
Selecione a Organização do GitHub, o Repositório e o Branch. Para implantar com o GitHub Actions, você deve ter acesso de gravação a este repositório.
Em Configurações de autenticação, escolha se o GitHub Actions deve ser autenticado com uma Identidade atribuída pelo usuário ou usando credenciais de Autenticação básica. Na autenticação básica, as credenciais atuais são usadas.
Selecione Visualizar arquivo para ver o arquivo de fluxo de trabalho que será adicionado ao repositório do GitHub no github/workflows/.
Selecione Salvar para adicionar o arquivo de fluxo de trabalho ao repositório.

Adicionar configuração de fluxo de trabalho ao seu repositório

Você pode usar o az functionapp deployment github-actions add comando para gerar um arquivo de configuração de fluxo de trabalho do modelo correto para seu aplicativo de funções. O novo arquivo YAML é armazenado no local correto (/.github/workflows/) no repositório GitHub que você fornece, enquanto o arquivo de perfil de publicação para seu aplicativo é adicionado aos segredos do GitHub no mesmo repositório.

Execute este comando do az functionapp, substituindo os valores githubUser/githubRepo, MyResourceGroupe MyFunctionapp:
```
az functionapp deployment github-actions add --repo "githubUser/githubRepo" -g MyResourceGroup -n MyFunctionapp --login-with-github
```
Esse comando usa um método interativo para recuperar um token de acesso pessoal para sua conta do GitHub.

Na janela do terminal, você deverá ver algo parecido com a seguinte mensagem:

Please navigate to https://github.com/login/device and enter the user code XXXX-XXXX to activate and retrieve your GitHub personal access token.

Copie o código exclusivo XXXX-XXXX, navegue até https://github.com/login/devicee insira o código copiado. Depois de inserir seu código, você deverá ver algo parecido com a seguinte mensagem:

Verified GitHub repo and branch
Getting workflow template using runtime: java
Filling workflow template with name: func-app-123, branch: main, version: 8, slot: production, build_path: .
Adding publish profile to GitHub
Fetching publish profile with secrets for the app 'func-app-123'
Creating new workflow file: .github/workflows/master_func-app-123.yml

Vá para o repositório GitHub e selecione Ações. Verifique se o fluxo de trabalho foi executado.

Criar o arquivo de configuração de fluxo de trabalho

Você pode criar o arquivo de configuração de fluxo de trabalho GitHub Actions dos modelos de Azure Functions diretamente do repositório GitHub.

No GitHub, acesse seu repositório.
Selecione Ações e Novo fluxo de trabalho.
Pesquise por funções.
Nos fluxos de trabalho do aplicativo de funções exibidas criados pelo Microsoft Azure, localize aquele que corresponde ao idioma do código e selecione Configurar.
No arquivo YAML recém-criado, atualize o parâmetro env.AZURE_FUNCTIONAPP_NAME com o nome do recurso do aplicativo de funções no Azure. Opcionalmente, você precisará atualizar o parâmetro que define a versão do idioma usada pelo aplicativo, como DOTNET_VERSION para C#.
Verifique se o novo arquivo de fluxo de trabalho está sendo salvo em /.github/workflows/ e selecione Confirmar alterações....

Atualizar uma configuração de fluxo de trabalho

Se, por algum motivo, você precisar atualizar ou alterar uma configuração de fluxo de trabalho existente, basta navegar até o local /.github/workflows/ em seu repositório, abrir o arquivo YAML específico, fazer as alterações necessárias e confirmar as atualizações no repositório.

Exemplo: arquivo de configuração de fluxo de trabalho

O exemplo a seguir usa a versão 1 do functions-action e um publish profile para autenticação. O modelo depende do idioma escolhido e do sistema operacional no qual o aplicativo de funções é implantado:

Windows
Linux

Se o aplicativo de funções for executado no Linux, selecione Linux.

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy DotNet project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'                   # set this to the dotnet version to use (e.g. '2.1.x', '3.1.x', '5.0.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup DotNet ${{ env.DOTNET_VERSION }} Environment
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}

    - name: 'Resolve Project Dependencies Using Dotnet'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        dotnet build --configuration Release --output ./output
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}/output'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: pwsh
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Java project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  POM_XML_DIRECTORY: '.'                    # set this to the directory which contains pom.xml file
  JAVA_VERSION: '8'                         # set this to the java version to use (e.g. '8', '11', '17')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Java Sdk ${{ env.JAVA_VERSION }}
      uses: actions/setup-java@v1
      with:
        java-version: ${{ env.JAVA_VERSION }}

    - name: 'Restore Project Dependencies Using Mvn'
      shell: bash
      run: |
        pushd './${{ env.POM_XML_DIRECTORY }}'
        mvn clean package
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: '${{ env.POM_XML_DIRECTORY }}' # if there are multiple function apps in same project, then this path will be like './${{ env.POM_XML_DIRECTORY }}/target/azure-functions/${{ env.POM_FUNCTIONAPP_NAME }'
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        respect-pom-xml: true

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: pwsh
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Node.js project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  NODE_VERSION: '16.x'                      # set this to the node version to use (e.g. '8.x', '10.x', '12.x')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Node ${{ env.NODE_VERSION }} Environment
      uses: actions/setup-node@v3
      with:
        node-version: ${{ env.NODE_VERSION }}

    - name: 'Resolve Project Dependencies Using Npm'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        npm install
        npm run build --if-present
        npm run test --if-present
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy Python project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
  PYTHON_VERSION: '3.9'                     # set this to the python version to use (e.g. '3.6', '3.7', '3.8')

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: Setup Python ${{ env.PYTHON_VERSION }} Environment
      uses: actions/setup-python@v4
      with:
        python-version: ${{ env.PYTHON_VERSION }}

    - name: 'Resolve Project Dependencies Using Pip'
      shell: bash
      run: |
        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
        python -m pip install --upgrade pip
        pip install -r requirements.txt --target=".python_packages/lib/site-packages"
        popd

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}
        scm-do-build-during-deployment: true
        enable-oryx-build: true

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: windows-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

name: Deploy PowerShell project to Azure Function App

on:
  [push]

env:
  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    environment: dev
    steps:
    - name: 'Checkout GitHub Action'
      uses: actions/checkout@v3

    - name: 'Run Azure Functions Action'
      uses: Azure/functions-action@v1
      id: fa
      with:
        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Ação do Azure Functions

A ação do Azure Functions (Azure/azure-functions) define como seu código é publicado em um aplicativo de funções existente no Azure ou em um slot específico em seu aplicativo.

Parâmetros

Os seguintes parâmetros são necessários para todos os planos do aplicativo de funções:

Parâmetro	Explicação
app-name	O nome da sua função.
package	Esse é o local em seu projeto a ser publicado. Por padrão, esse valor é definido como `.`, o que significa que todos os arquivos e pastas no repositório GitHub são implantados.

Os seguintes parâmetros são necessários para o plano de Consumo Flex:

Parâmetro	Explicação
sku	Defina isso como `flexconsumption`ao autenticar com o perfil de publicação. Ao usar credenciais RBAC ou implantar em um plano de Consumo não Flex, a Ação pode resolver o valor, portanto, o parâmetro não precisa ser incluído.
remote-build	Defina isso como `true` para habilitar uma ação de build do Kudu quando o pacote for implantado em um aplicativo de Consumo Flex. O build Oryx é sempre executado durante um build remoto no Consumo Flex; não defina scm-do-build-during-deployment ou enable-oryx-build. Por padrão, esse parâmetro é definido como `false`.

Os seguintes parâmetros são específicos para os planos Consumo, Elástico Premium e Serviço de Aplicativo (Dedicado):

Parâmetro Explicação

scm-do-build-during-deployment (Opcional) Permitir que o site do Kudu (por exemplo https://<APP_NAME>.scm.azurewebsites.net/) execute operações de pré-implantação, como builds remotos. Por padrão, ele é definido como false. Defina isso como true quando você quiser controlar os comportamentos de implantação usando o Kudu em vez de resolver dependências em seu fluxo de trabalho do GitHub. Para obter mais informações, connsulte o SCM_DO_BUILD_DURING_DEPLOYMENT.

enable-oryx-build (Opcional) Permitir que o site do Kudu resolva as dependências do projeto com o Oryx. Por padrão, ele é definido como false. Se você quiser usar o Oryx para resolver suas dependências em vez do Fluxo de Trabalho do GitHub, defina scm-do-build-during-deployment e enable-oryx-build como true.

Parâmetro	Explicação
scm-do-build-during-deployment	(Opcional) Permitir que o site do Kudu (por exemplo `https://<APP_NAME>.scm.azurewebsites.net/`) execute operações de pré-implantação, como builds remotos. Por padrão, ele é definido como `false`. Defina isso como `true` quando você quiser controlar os comportamentos de implantação usando o Kudu em vez de resolver dependências em seu fluxo de trabalho do GitHub. Para obter mais informações, connsulte o `SCM_DO_BUILD_DURING_DEPLOYMENT`.
enable-oryx-build	(Opcional) Permitir que o site do Kudu resolva as dependências do projeto com o Oryx. Por padrão, ele é definido como `false`. Se você quiser usar o Oryx para resolver suas dependências em vez do Fluxo de Trabalho do GitHub, defina scm-do-build-during-deployment e enable-oryx-build como `true`.

Parâmetros opcionais para todos os planos do aplicativo de funções:

Parâmetro	Explicação
slot-name	Esse é o nome do slot de implantação a ser implantado. Por padrão, esse valor está vazio, o que significa que o GitHub Action será implantado em seu site de produção. Quando essa configuração aponta para um slot de não produção, verifique se o parâmetro publish-profile contém as credenciais do slot em vez do site de produção. No momento, não há suporte para Consumo Flex.
publish-profile	(Opcional) O nome do segredo do GitHub para seu perfil de publicação.
respect-pom-xml	(Opcional) Usado apenas para funções Java. Se é necessário que o artefato de implantação do aplicativo seja derivado do arquivo pom.xml. Ao implantar aplicativos de funções Java, você deve definir esse parâmetro como `true` e definir `package` como `.`. Por padrão, esse parâmetro é definido como `false`, o que significa que o parâmetro `package` deve apontar para o local do artefato do aplicativo, como `./target/azure-functions/`
respect-funcignore	(Opcional) Se GitHub Actions honra seu arquivo .funcignore para excluir arquivos e pastas definidos nele. Defina esse vale como `true` quando o repositório tiver um arquivo .funcignore e você quiser usá-lo para excluir caminhos e arquivos, como configurações do editor de texto, .vscode/ou um ambiente virtual do Python (.venv/). A configuração padrão é `false`.

Considerações

Tenha em mente as seguintes considerações ao usar a ação do Azure Functions:

Ao usar o GitHub Actions, o código é implantado usando uma implantação em aplicativos no plano de Consumo Flexível e implantação zip em aplicativos nos planos de Consumo, Elástico Premium e Dedicado (Serviço de Aplicativo). A exceção é o Consumo em Linux, onde o URL do pacote externo é usado.
As credenciais exigidas pelo GitHub para conexão com o Azure para implantação são armazenadas como Segredos em seu repositório GitHub e acessadas na implantação como secrets.<SECRET_NAME>.
A maneira recomendada de autenticar com o Azure Functions para o GitHub Actions é usando um perfil de publicação. Você também pode autenticar com uma entidade de serviço. Para saber mais, confira este repositório do GitHub Actions.
As ações para configurar o ambiente e executar um build são geradas a partir dos modelos e são específicas do idioma.
Os modelos usam elementos env para definir configurações exclusivas para sua compilação e implantação.

Próximas etapas

Saiba mais sobre a integração do Azure com o GitHub

Compartilhar via