Configurar a implantação do GitHub Actions ao criar o aplicativo
A implantação do GitHub Actions é integrada ao assistente de criação de aplicativos padrão. Você só precisa definir Implantação contínua como Habilitar na guia Implantação e configurar a organização, o repositório e a ramificação desejados.
Quando você habilita a implantação contínua, o assistente de criação de aplicativos seleciona 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 a partir do Centro de Implantação
Para um aplicativo existente, você pode começar rapidamente com as Ações do GitHub usando o Centro de Implantação do Serviço de Aplicativo. Esse método turn-key gera automaticamente um arquivo de fluxo de trabalho GitHub Actions com base em sua pilha de aplicativos e o confirma em seu repositório GitHub.
O Centro de Implementação também permite configurar facilmente a autenticação OpenID Connect mais segura com a opção de identidade atribuída pelo utilizador.
Se 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, você pode selecionar uma identidade gerenciada atribuída ao usuário existente no menu suspenso Identidade . Você pode trabalhar com o administrador do Azure para criar uma identidade gerenciada atribuída pelo usuário com a função de Colaborador do Site.
A maneira recomendada de autenticar com os Serviços de Aplicativo do Azure para Ações do GitHub é 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.
A seguir você percorre as etapas para criar um aplicativo de diretório ativo, entidade de serviço e credenciais federadas usando instruções da CLI do Azure. Para saber como criar um aplicativo de diretório ativo, entidade de serviço e credenciais federadas no portal do Azure, consulte Conectar o GitHub e o Azure.
Este comando gera uma saída JSON com um appId que é o seu client-id. Salve o valor para usar como o segredo do AZURE_CLIENT_ID GitHub mais tarde.
Você usará o valor ao criar credenciais federadas com a API do Graph e fará referência a objectId ele como o APPLICATION-OBJECT-ID.
Crie uma entidade de serviço. Substitua o $appID pelo appId da sua saída JSON.
Este comando gera saída JSON com um diferente objectId e será usado na próxima etapa. O novo objectId é o assignee-object-id.
Copie o appOwnerTenantId para usar como um segredo do GitHub para AZURE_TENANT_ID mais tarde.
az ad sp create --id $appId
Crie uma nova atribuição de função por assinatura e objeto. Por padrão, a atribuição de função está vinculada à sua assinatura padrão. Substitua $subscriptionId pelo ID da assinatura, $resourceGroupName pelo nome do grupo de recursos, $webappName pelo nome do aplicativo Web e $assigneeObjectId pelo arquivo id. Saiba como gerenciar 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
Execute o seguinte comando para criar uma nova credencial de identidade federada para seu aplicativo Ative Directory.
Substitua APPLICATION-OBJECT-ID pelo appId (gerado durante a criação do aplicativo) para seu aplicativo do Ative Directory.
Defina um valor para CREDENTIAL-NAME referenciar mais tarde.
Defina o subjectarquivo . Seu valor é definido pelo GitHub dependendo do seu fluxo de trabalho:
Trabalhos em seu ambiente de ações do GitHub: repo:< Organization/Repository >:environment:< Name >
Para Trabalhos não vinculados a um ambiente, inclua o caminho ref para ramificação/tag com base no caminho ref usado para acionar 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 acionados por um evento pull request: 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"
]
}
Nota
O perfil de publicação requer autenticação básica para ser habilitado.
Um perfil de publicação é uma credencial no nível do aplicativo. Configure seu perfil de publicação como um segredo do GitHub.
Aceda ao serviço da sua aplicação 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.
Nota
A partir de outubro de 2020, os aplicativos Web Linux precisam da configuração WEBSITE_WEBDEPLOY_USE_SCM do aplicativo definida para trueantes de baixar o perfil de publicação. Este requisito será suprimido 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 seu aplicativo do Serviço de Aplicativo semelhante ao trecho JSON a seguir. Copie este objeto JSON para mais tarde.
É sempre uma boa prática conceder acesso mínimo. O escopo no exemplo anterior é limitado ao aplicativo do Serviço de Aplicativo específico e não a todo o grupo de recursos.
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 seu repositório GitHub e vá para Configurações > Segredos de segurança > e variáveis > Ações > Novo segredo do repositório.
Crie segredos para AZURE_CLIENT_ID, AZURE_TENANT_IDe AZURE_SUBSCRIPTION_ID. Use estes valores do seu aplicativo Ative Directory para seus segredos do GitHub:
Segredo do GitHub
Aplicativo Ative Directory
AZURE_CLIENT_ID
ID da aplicação (cliente)
AZURE_TENANT_ID
ID do Diretório (inquilino)
AZURE_SUBSCRIPTION_ID
ID de Subscrição
Salve cada segredo selecionando Adicionar segredo.
No GitHub, navegue pelo repositório. Selecione Configurações > Segredos de segurança > e variáveis > Ações > Novo segredo do repositório.
Para usar credenciais no nível do aplicativo, cole o conteúdo do arquivo de perfil de publicação baixado no campo de valor do segredo. Nomeie o segredo AZURE_WEBAPP_PUBLISH_PROFILE.
Ao configurar o arquivo de fluxo de trabalho do GitHub posteriormente, você usa a ação implantar o AZURE_WEBAPP_PUBLISH_PROFILE Azure Web App. Por exemplo:
No GitHub, navegue pelo repositório. Selecione Configurações > Segredos de segurança > e variáveis > Ações > Novo segredo do repositório.
Para usar credenciais de nível de usuário, cole toda a saída JSON do comando CLI do Azure no campo de valor do segredo. Nomeie o segredo AZURE_CREDENTIALS.
Ao configurar o arquivo de fluxo de trabalho do GitHub posteriormente, você usa o segredo para a entrada creds do Azure/login. Por exemplo:
3. Adicione o arquivo de fluxo de trabalho ao repositório do GitHub
Um fluxo de trabalho é definido por um arquivo YAML (.yml) no /.github/workflows/ caminho no repositório do GitHub. Esta definição contém as várias etapas e parâmetros que compõem o fluxo de trabalho.
No mínimo, o arquivo de fluxo de trabalho teria as seguintes etapas distintas:
Autentique-se com o Serviço de Aplicativo usando o segredo do GitHub que você criou.
Crie o aplicativo Web.
Implante o aplicativo Web.
Para implantar 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 e app-name , dependendo da sua 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 azure/webapps-deploy@v3 ação, consulte a definição de action.yml .
Os exemplos a seguir mostram a parte do fluxo de trabalho que cria o aplicativo Web, em diferentes idiomas suportados.
Para implantar com o OpenID Connect usando a identidade gerenciada que você configurou, use a azure/login@v1 ação com as client-idchaves , tenant-ide subscription-id e faça referência aos segredos do GitHub criados 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 client-idvalores , tenant-ide subscription-id . Você também pode passar esses valores diretamente na ação de login.
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 client-idvalores , tenant-ide subscription-id . Você também pode passar esses valores diretamente na ação de login.
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ê pode encontrar este exemplo completo usando vários trabalhos para criar e implantar aqui também.
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 publish-profile entrada deve fazer referência ao segredo do AZURE_WEBAPP_PUBLISH_PROFILE GitHub 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 MVC ASP.NET que usa 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 publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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 package valor.
Crie e implante um aplicativo Tomcat no Azure usando um perfil de publicação do Azure. A publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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ê pode encontrar este exemplo completo usando vários trabalhos para criar e implantar aqui também.
Crie e implante um aplicativo Node.js no Azure usando o perfil de publicação do aplicativo. A publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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 o perfil de publicação do aplicativo. Observe como a publish-profile entrada faz referência ao AZURE_WEBAPP_PUBLISH_PROFILE segredo que você criou 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 com a creds chave e faça referência ao AZURE_CREDENTIALSazure/login@v1 segredo criado 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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ê pode encontrar este exemplo completo usando vários trabalhos para criar e implantar aqui também.
Crie e implante um aplicativo Node.js no Azure usando uma entidade de serviço do Azure. Observe como a creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 creds entrada faz referência ao AZURE_CREDENTIALS segredo que você criou 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 faço para implantar um arquivo WAR através do plug-in Maven?
Caso você tenha configurado seu projeto Java Tomcat com o plug-in Maven, também poderá implantar no Serviço de Aplicativo do Azure por meio desse plug-in. Se você usar a ação GitHub da CLI do Azure, ela usará suas credenciais de logon do Azure.
Mais informações sobre o plug-in Maven e como usá-lo e configurá-lo podem ser encontradas no wiki do plug-in Maven para o Serviço de Aplicativo do Azure.
Como faço para implantar um arquivo WAR através da Az CLI?
Se você preferir a CLI do Azure para implantar no Serviço de Aplicativo, poderá usar a Ação do GitHub para CLI do Azure.
Mais informações sobre a Ação do GitHub para CLI e como usá-la e configurá-la podem ser encontradas na ação GitHub da CLI do Azure.
Mais informações sobre o comando az webapp deploy, como usar e os detalhes do parâmetro podem ser encontradas na documentação az webapp deploy.
Com a ação Implantação da Web do Azure, você pode automatizar seu fluxo de trabalho para implantar contêineres personalizados no Serviço de Aplicativo usando as Ações do GitHub. Informações detalhadas sobre as etapas de implantação usando as Ações do GitHub podem ser encontradas em Implantar em um contêiner.
Como atualizo a configuração do Tomcat após a implantação?
Caso deseje atualizar qualquer uma das configurações de seus aplicativos Web após a implantação, você pode 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
Mais informações sobre essa ação e como usá-la e configurá-la podem ser encontradas no repositório de Configurações do Serviço de Aplicativo.
Próximos passos
Confira as referências sobre Ações e fluxos de trabalho do GitHub do Azure:
