Uma conta do GitHub. Caso ainda não tenha uma, inscreva-se gratuitamente.
Configurar a implantação do GitHub Actions ao criar o aplicativo
A implantação do GitHub Actions é integrada ao assistente de criação de aplicativo padrão. Você só precisa configurar a Implantação contínua para Habilitar na guia Implantação e configurar a organização, o repositório e a ramificação desejada.
Quando você habilita a implantação contínua, o assistente de criação de aplicativo escolhe automaticamente o método de autenticação com base na seleção de autenticação básica e configura seu aplicativo e seu repositório GitHub de acordo:
Configurar a implantação do GitHub Actions no Centro de Implantação
Para um aplicativo existente, você pode começar rapidamente com o GitHub Actions usando o Centro de Implantação do Serviço de Aplicativo. Este método pronto para uso gera automaticamente um arquivo de fluxo de trabalho do GitHub Actions com base na pilha de aplicativos e o envia para o repositório GitHub.
Se a sua conta do Azure tiver as permissões necessárias, você poderá optar por criar uma identidade atribuída pelo usuário. Caso contrário, poderá selecionar uma identidade gerenciada atribuída pelo usuário existente na lista suspensa Identidade. Você pode trabalhar com o administrador do Azure para criar uma identidade gerenciada atribuída pelo usuário com a função Colaborador do Site.
A maneira recomendada de autenticar com os Serviços de Aplicativo do Azure para GitHub Actions é com o OpenID Connect. Este é um método de autenticação que usa tokens de curta duração. Configurar o OpenID Connect com o GitHub Actions é mais complexo, mas oferece segurança reforçada.
Como alternativa, você pode autenticar com uma Identidade Gerenciada atribuída pelo usuário, uma entidade de serviço ou um perfil de publicação.
O artigo abaixo mostra a você as etapas de criação de um aplicativo do Active Directory, uma entidade de serviço e credenciais federadas usando instruções da CLI do Azure. Para saber como criar um aplicativo do Active Directory, uma entidade de serviço e credenciais federadas no portal do Azure, confira Conectar o GitHub e o Azure.
Esse comando gera um JSON com um appId que é seu client-id. Salve o valor para usar mais tarde como o segredo AZURE_CLIENT_ID do GitHub.
Você usará o valor objectId ao criar credenciais federadas com a API do Graph e ao referenciá-la como o APPLICATION-OBJECT-ID.
Crie uma entidade de serviço. Substitua $appID pelo AppID de sua saída JSON.
Esse comando gera uma saída JSON com um objectId diferente e será usado na próxima etapa. O novo objectId é o assignee-object-id.
Copie o appOwnerTenantId para usar mais tarde como um segredo do GitHub para AZURE_TENANT_ID.
az ad sp create --id $appId
Crie uma atribuição de função por assinatura e objeto. Por padrão, a atribuição de função é vinculada à sua assinatura padrão. Substitua $subscriptionId pela ID da assinatura, $resourceGroupName pelo nome do grupo de recursos, $webappName pelo nome do aplicativo Web e $assigneeObjectId pelo id gerado. Saiba como gerenciar as assinaturas do Azure com a CLI do Azure.
az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/$webappName --assignee-principal-type ServicePrincipal
Substitua APPLICATION-OBJECT-ID pela appId (gerada durante a criação do aplicativo) para o seu aplicativo do Active Directory.
Defina um valor de CREDENTIAL-NAME para referência posterior.
Defina o subject. Seu valor é definido pelo GitHub dependendo do fluxo de trabalho:
Trabalhos em seu ambiente do GitHub Actions: repo:< Organization/Repository >:environment:< Name >
Para trabalhos não vinculados a um ambiente, inclua o caminho de referência para ramificação/marca com base no caminho de referência usado para disparar o fluxo de trabalho: repo:< Organization/Repository >:ref:< ref path>. Por exemplo, repo:n-username/ node_express:ref:refs/heads/my-branch ou repo:n-username/ node_express:ref:refs/tags/my-tag.
Para fluxos de trabalho disparados por um evento de solicitação de pull: repo:< Organization/Repository >:pull_request.
az ad app federated-credential create --id <APPLICATION-OBJECT-ID> --parameters credential.json
("credential.json" contains the following content)
{
"name": "<CREDENTIAL-NAME>",
"issuer": "https://token.actions.githubusercontent.com",
"subject": "repo:organization/repository:ref:refs/heads/main",
"description": "Testing",
"audiences": [
"api://AzureADTokenExchange"
]
}
Um perfil de publicação é uma credencial de nível de aplicativo. Configure o perfil de publicação como segredo do GitHub.
Acesse o serviço de aplicativo no portal do Azure.
Na página Visão geral, selecione Obter perfil de publicação.
Salve o arquivo baixado. Você usará o conteúdo do arquivo para criar um segredo do GitHub.
Observação
A partir de outubro de 2020, os aplicativos Web do Linux precisam da configuração do aplicativo WEBSITE_WEBDEPLOY_USE_SCM definida como trueantes de baixar o perfil de publicação. Esse requisito será removido no futuro.
az ad sp create-for-rbac --name "myApp" --role contributor \
--scopes /subscriptions/<subscription-id>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name> \
--json-auth
No exemplo anterior, substitua os espaços reservados pela ID da assinatura, nome do grupo de recursos e nome do aplicativo. A saída é um objeto JSON com as credenciais de atribuição de função que fornecem acesso ao aplicativo do Serviço de Aplicativo semelhante ao seguinte snippet JSON. Copie esse objeto JSON para uso posterior.
É sempre uma boa prática permitir acesso mínimo. O escopo no exemplo anterior é limitado ao aplicativo do Serviço de Aplicativo e não ao grupo de recursos inteiro.
Você precisa fornecer a ID do cliente, a ID do locatário e a ID da assinatura do seu aplicativo para a ação Azure/login. Esses valores podem ser fornecidos diretamente no fluxo de trabalho ou podem ser armazenados em segredos do GitHub e referenciados em seu fluxo de trabalho. Salvar os valores como segredos do GitHub é a opção mais segura.
Abra o repositório GitHub e acesse Configurações > Segurança > Segredos e variáveis > Ações > Novo segredo do repositório.
Crie segredos para AZURE_CLIENT_ID, AZURE_TENANT_ID e AZURE_SUBSCRIPTION_ID. Use esses valores do seu aplicativo do Active Directory para seus segredos do GitHub:
Segredo do GitHub
Aplicativo do AD DS
AZURE_CLIENT_ID
ID do aplicativo (cliente)
AZURE_TENANT_ID
ID do diretório (locatário)
AZURE_SUBSCRIPTION_ID
ID da assinatura
Salve cada segredo selecionando Adicionar segredo.
Em GitHub, procure seu repositório. Selecione Configurações > Segurança > Segredos e variáveis > Ações > Novo segredo do repositório.
Para usar as credenciais de nível de aplicativo, cole o conteúdo do arquivo de perfil de publicação baixado no campo de valor do segredo. Nomeie o segredo como AZURE_WEBAPP_PUBLISH_PROFILE.
Ao configurar o arquivo de fluxo de trabalho do GitHub posteriormente, use o AZURE_WEBAPP_PUBLISH_PROFILE na ação implantar o Aplicativo Web do Azure. Por exemplo:
Em GitHub, procure seu repositório. Selecione Configurações > Segurança > Segredos e variáveis > Ações > Novo segredo do repositório.
Para usar as credenciais de nível de usuário, cole toda a saída JSON do comando da CLI do Azure no campo de valor do segredo. Nomeie o segredo como AZURE_CREDENTIALS.
Ao configurar o arquivo de fluxo de trabalho do GitHub posteriormente, use o segredo para a entrada creds do Azure/login. Por exemplo:
3. Adicionar o arquivo de fluxo de trabalho ao repositório GitHub
Um fluxo de trabalho é definido por um arquivo YAML (.yml) no caminho /.github/workflows/ do seu repositório GitHub. Essa definição contém as várias etapas e os parâmetros que compõem o fluxo de trabalho.
No mínimo, o arquivo de fluxo de trabalho teria as seguintes etapas distintas:
Autenticar com o Serviço de Aplicativo usando o segredo do GitHub que você criou.
Criar o aplicativo Web.
Implantar o aplicativo Web.
Para implementar o seu código em um aplicativo do Serviço de Aplicativo, use a ação azure/webapps-deploy@v3. A ação requer o nome do seu aplicativo Web no app-name e, dependendo da pilha de idiomas, o caminho de um *.zip, *.war, *.jar ou pasta para implantar no package. Para obter uma lista completa de possíveis entradas para a ação azure/webapps-deploy@v3, confira a definição action.yml.
Os exemplos a seguir mostram a parte do fluxo de trabalho que cria o aplicativo Web, nos diferentes idiomas compatíveis.
Para implantar com o OpenID Connect usando a identidade gerenciada configurada, use a ação azure/login@v1 com as chaves client-id, tenant-id e subscription-id e faça referência aos segredos do GitHub que você criou anteriormente.
name: .NET Core
on: [push]
permissions:
id-token: write
contents: read
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
DOTNET_VERSION: '6.0.x' # set this to the dot net version to use
jobs:
build:
runs-on: ubuntu-latest
steps:
# Checkout the repo
- uses: actions/checkout@main
- uses: azure/login@v1
with:
client-id: ${{ secrets.AZURE_CLIENT_ID }}
tenant-id: ${{ secrets.AZURE_TENANT_ID }}
subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
# Setup .NET Core SDK
- name: Setup .NET Core
uses: actions/setup-dotnet@v3
with:
dotnet-version: ${{ env.DOTNET_VERSION }}
# Run dotnet build and publish
- name: dotnet build and publish
run: |
dotnet restore
dotnet build --configuration Release
dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
# Deploy to Azure Web apps
- name: 'Run Azure webapp deploy action using publish profile credentials'
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
- name: logout
run: |
az logout
Crie e implante um aplicativo ASP.NET MVC no Azure usando uma entidade de serviço do Azure. O exemplo usa segredos do GitHub para os valores client-id, tenant-id e subscription-id. Você também pode passar esses valores diretamente na ação de logon.
name: Deploy ASP.NET MVC App deploy to Azure Web App
on: [push]
permissions:
id-token: write
contents: read
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
NUGET_VERSION: '5.3.x' # set this to the dot net version to use
jobs:
build-and-deploy:
runs-on: windows-latest
steps:
# checkout the repo
- uses: actions/checkout@main
- uses: azure/login@v1
with:
client-id: ${{ secrets.AZURE_CLIENT_ID }}
tenant-id: ${{ secrets.AZURE_TENANT_ID }}
subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
- name: Install Nuget
uses: nuget/setup-nuget@v1
with:
nuget-version: ${{ env.NUGET_VERSION}}
- name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
run: nuget restore
- name: Add msbuild to PATH
uses: microsoft/setup-msbuild@v1.0.2
- name: Run MSBuild
run: msbuild .\SampleWebApplication.sln
- name: 'Run Azure webapp deploy action using publish profile credentials'
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'
# Azure logout
- name: logout
run: |
az logout
Crie e implante um aplicativo Java Spring no Azure usando uma entidade de serviço do Azure. O exemplo usa segredos do GitHub para os valores client-id, tenant-id e subscription-id. Você também pode passar esses valores diretamente na ação de logon.
name: Build and deploy WAR app to Azure Web App using OpenID Connect
env:
JAVA_VERSION: '11' # set this to the Java version to use
DISTRIBUTION: microsoft # set this to the Java distribution
AZURE_WEBAPP_NAME: sampleapp # set this to the name of your web app
on: [push]
permissions:
id-token: write
contents: read
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Java version
uses: actions/setup-java@v3.0.0
with:
java-version: ${{ env.JAVA_VERSION }}
distribution: ${{ env.DISTRIBUTION }}
cache: 'maven'
- name: Build with Maven
run: mvn clean install
- name: Login to Azure
uses: azure/login@v2
with:
client-id: ${{ secrets.AZURE_CLIENT_ID }}
tenant-id: ${{ secrets.AZURE_TENANT_ID }}
subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
- name: Deploy to Azure Web App
id: deploy-to-webapp
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: '*.war'
Você também pode encontrar este exemplo completo usando vários trabalhos para compilar e implantar aqui.
name: JavaScript CI
on: [push]
permissions:
id-token: write
contents: read
name: Node.js
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path' # set this to the path to your web app project, defaults to the repository root
NODE_VERSION: '18.x' # set this to the node version to use
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
# checkout the repo
- name: 'Checkout GitHub Action'
uses: actions/checkout@main
- uses: azure/login@v1
with:
client-id: ${{ secrets.AZURE_CLIENT_ID }}
tenant-id: ${{ secrets.AZURE_TENANT_ID }}
subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
- name: Setup Node ${{ env.NODE_VERSION }}
uses: actions/setup-node@v4
with:
node-version: ${{ env.NODE_VERSION }}
- name: 'npm install, build, and test'
run: |
npm install
npm run build --if-present
npm run test --if-present
working-directory: my-app-path
# deploy web app using Azure credentials
- uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
# Azure logout
- name: logout
run: |
az logout
name: Python application
on:
[push]
permissions:
id-token: write
contents: read
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: azure/login@v1
with:
client-id: ${{ secrets.AZURE_CLIENT_ID }}
tenant-id: ${{ secrets.AZURE_TENANT_ID }}
subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
- name: Set up Python 3.x
uses: actions/setup-python@v4
with:
python-version: 3.x
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Deploy web App using GH Action azure/webapps-deploy
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
- name: logout
run: |
az logout
A entrada publish-profile deve fazer referência ao segredo do GitHub AZURE_WEBAPP_PUBLISH_PROFILE que você criou anteriormente.
name: .NET Core CI
on: [push]
env:
AZURE_WEBAPP_NAME: my-app-name # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
DOTNET_VERSION: '6.0.x' # set this to the dot net version to use
jobs:
build:
runs-on: ubuntu-latest
steps:
# Checkout the repo
- uses: actions/checkout@main
# Setup .NET Core SDK
- name: Setup .NET Core
uses: actions/setup-dotnet@v3
with:
dotnet-version: ${{ env.DOTNET_VERSION }}
# Run dotnet build and publish
- name: dotnet build and publish
run: |
dotnet restore
dotnet build --configuration Release
dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
# Deploy to Azure Web apps
- name: 'Run Azure webapp deploy action using publish profile credentials'
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }} # Define secret variable in repository settings as per action documentation
package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
Crie e implante um aplicativo ASP.NET MVC que usa o NuGet e publish-profile para autenticação.
name: Deploy ASP.NET MVC App deploy to Azure Web App
on: [push]
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
NUGET_VERSION: '5.3.x' # set this to the dot net version to use
jobs:
build-and-deploy:
runs-on: windows-latest
steps:
- uses: actions/checkout@main
- name: Install Nuget
uses: nuget/setup-nuget@v1
with:
nuget-version: ${{ env.NUGET_VERSION}}
- name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
run: nuget restore
- name: Add msbuild to PATH
uses: microsoft/setup-msbuild@v1.0.2
- name: Run MSBuild
run: msbuild .\SampleWebApplication.sln
- name: 'Run Azure webapp deploy action using publish profile credentials'
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }} # Define secret variable in repository settings as per action documentation
package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'
Crie e implante um aplicativo Java Spring no Azure usando um perfil de publicação do Azure. A entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.
name: Java CI with Maven
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up JDK 1.8
uses: actions/setup-java@v3
with:
java-version: 1.8
- name: Build with Maven
run: mvn -B package --file pom.xml
working-directory: my-app-path
- name: Azure WebApp
uses: Azure/webapps-deploy@v3
with:
app-name: my-app-name
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: my/target/*.jar
Para implantar um war em vez de um jar, altere o valor package.
Crie e implante um aplicativo Tomcat no Azure usando um perfil de publicação do Azure. A entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.
name: Build and deploy WAR app to Azure Web App using publish profile
env:
JAVA_VERSION: '11' # set this to the Java version to use
DISTRIBUTION: microsoft # set this to the Java distribution
AZURE_WEBAPP_NAME: sampleapp # set this to the name of your web app
on: [push]
permissions:
id-token: write
contents: read
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Java version
uses: actions/setup-java@v3.0.0
with:
java-version: ${{ env.JAVA_VERSION }}
distribution: ${{ env.DISTRIBUTION }}
cache: 'maven'
- name: Build with Maven
run: mvn clean install
- name: Deploy to Azure Web App
id: deploy-to-webapp
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: '*.war'
Você também pode encontrar este exemplo completo usando vários trabalhos para compilar e implantar aqui.
Crie e implante um aplicativo Node.js no Azure usando um perfil de publicação do aplicativo. A entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.
# File: .github/workflows/workflow.yml
name: JavaScript CI
on: [push]
env:
AZURE_WEBAPP_NAME: my-app-name # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path' # set this to the path to your web app project, defaults to the repository root
NODE_VERSION: '18.x' # set this to the node version to use
jobs:
build-and-deploy:
name: Build and Deploy
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@main
- name: Use Node.js ${{ env.NODE_VERSION }}
uses: actions/setup-node@v4
with:
node-version: ${{ env.NODE_VERSION }}
- name: npm install, build, and test
run: |
# Build and test the project, then
# deploy to Azure Web App.
npm install
npm run build --if-present
npm run test --if-present
working-directory: my-app-path
- name: 'Deploy to Azure WebApp'
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
Crie e implante um aplicativo Python no Azure usando um perfil de publicação do aplicativo. Observe como a entrada publish-profile referencia o segredo AZURE_WEBAPP_PUBLISH_PROFILE criado anteriormente.
name: Python CI
on:
[push]
env:
AZURE_WEBAPP_NAME: my-web-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Python 3.x
uses: actions/setup-python@v4
with:
python-version: 3.x
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Building web app
uses: azure/appservice-build@v2
- name: Deploy web App using GH Action azure/webapps-deploy
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
Para implantar com a entidade de serviço configurada, use a ação azure/login@v1 com a chave creds e faça referência ao segredo AZURE_CREDENTIALS que você criou anteriormente.
name: .NET Core
on: [push]
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
DOTNET_VERSION: '6.0.x' # set this to the dot net version to use
jobs:
build:
runs-on: ubuntu-latest
steps:
# Checkout the repo
- uses: actions/checkout@main
- uses: azure/login@v1
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
# Setup .NET Core SDK
- name: Setup .NET Core
uses: actions/setup-dotnet@v3
with:
dotnet-version: ${{ env.DOTNET_VERSION }}
# Run dotnet build and publish
- name: dotnet build and publish
run: |
dotnet restore
dotnet build --configuration Release
dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
# Deploy to Azure Web apps
- name: 'Run Azure webapp deploy action using Azure Credentials'
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
- name: logout
run: |
az logout
Crie e implante um aplicativo ASP.NET MVC no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.
name: Deploy ASP.NET MVC App deploy to Azure Web App
on: [push]
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
NUGET_VERSION: '5.3.x' # set this to the dot net version to use
jobs:
build-and-deploy:
runs-on: windows-latest
steps:
# checkout the repo
- uses: actions/checkout@main
- uses: azure/login@v1
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Install Nuget
uses: nuget/setup-nuget@v1
with:
nuget-version: ${{ env.NUGET_VERSION}}
- name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
run: nuget restore
- name: Add msbuild to PATH
uses: microsoft/setup-msbuild@v1.0.2
- name: Run MSBuild
run: msbuild .\SampleWebApplication.sln
- name: 'Run Azure webapp deploy action using Azure Credentials'
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'
# Azure logout
- name: logout
run: |
az logout
Crie e implante um aplicativo Java Spring no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.
name: Java CI with Maven
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: azure/login@v1
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Set up JDK 1.8
uses: actions/setup-java@v3
with:
java-version: 1.8
- name: Build with Maven
run: mvn -B package --file pom.xml
working-directory: complete
- name: Azure WebApp
uses: Azure/webapps-deploy@v3
with:
app-name: my-app-name
package: my/target/*.jar
# Azure logout
- name: logout
run: |
az logout
Crie e implante um aplicativo Tomcat no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.
name: Build and deploy WAR app to Azure Web App using Service Principal Connect
env:
JAVA_VERSION: '11' # set this to the Java version to use
DISTRIBUTION: microsoft # set this to the Java distribution
AZURE_WEBAPP_NAME: sampleapp # set this to the name of your web app
on: [push]
permissions:
contents: read
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Java version
uses: actions/setup-java@v3.0.0
with:
java-version: ${{ env.JAVA_VERSION }}
distribution: ${{ env.DISTRIBUTION }}
cache: 'maven'
- name: Build with Maven
run: mvn clean install
- name: Login to Azure
uses: azure/login@v2
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Deploy to Azure Web App
id: deploy-to-webapp
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: '*.war'
Você também pode encontrar este exemplo completo usando vários trabalhos para compilar e implantar aqui.
Crie e implante um aplicativo Node.js no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.
name: JavaScript CI
on: [push]
name: Node.js
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path' # set this to the path to your web app project, defaults to the repository root
NODE_VERSION: '18.x' # set this to the node version to use
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
# checkout the repo
- name: 'Checkout GitHub Action'
uses: actions/checkout@main
- uses: azure/login@v1
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Setup Node ${{ env.NODE_VERSION }}
uses: actions/setup-node@v4
with:
node-version: ${{ env.NODE_VERSION }}
- name: 'npm install, build, and test'
run: |
npm install
npm run build --if-present
npm run test --if-present
working-directory: my-app-path
# deploy web app using Azure credentials
- uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
# Azure logout
- name: logout
run: |
az logout
Crie e implante um aplicativo Python no Azure usando uma entidade de serviço do Azure. Observe como a entrada creds referencia o segredo AZURE_CREDENTIALS criado anteriormente.
name: Python application
on:
[push]
env:
AZURE_WEBAPP_NAME: my-app # set this to your application's name
AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: azure/login@v1
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Set up Python 3.x
uses: actions/setup-python@v4
with:
python-version: 3.x
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Deploy web App using GH Action azure/webapps-deploy
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
- name: logout
run: |
az logout
Como implantar um arquivo WAR por meio do plug-in do Maven e do OpenID Connect
Caso você tenha configurado o seu projeto Java Tomcat com o plug-in do Maven, você também pode implantar no Serviço de Aplicativo do Azure por meio desse plug-in. Se você usar a ação do GitHub da CLI do Azure, ela usará suas credenciais de logon do Azure.
Mais informações sobre a Ação do GitHub para a CLI e como usá-la e configurá-la podem ser encontradas em Ação do GitHub da CLI do Azure.
Mais informações sobre o comando az webapp deploy, como usá-lo e os detalhes do parâmetro podem ser encontrados na documentação do az webapp deploy.
Como fazer para implantar em um contêiner
Com a ação da Implantação da Web do Azure, você pode automatizar seu fluxo de trabalho a fim de implantar contêineres personalizados no Serviço de Aplicativo usando o GitHub Actions. Informações detalhadas sobre as etapas de implantação usando o GitHub Actions podem ser encontradas em Implantação em um contêiner.
Como atualizar a configuração do Tomcat após a implantação
Caso você queira atualizar qualquer uma de suas configurações de aplicativos Web após a implantação, poderá usar a ação Configurações do Serviço de Aplicativo.
- uses: azure/appservice-settings@v1
with:
app-name: 'my-app'
slot-name: 'staging' # Optional and needed only if the settings have to be configured on the specific deployment slot
app-settings-json: '[{ "name": "CATALINA_OPTS", "value": "-Dfoo=bar" }]'
connection-strings-json: '${{ secrets.CONNECTION_STRINGS }}'
general-settings-json: '{"alwaysOn": "false", "webSocketsEnabled": "true"}' #'General configuration settings as Key Value pairs'
id: settings
