Configuración de la implementación de Acciones de GitHub al crear la aplicación
La implementación de las Acciones de GitHub está integrada en la aplicación predeterminada Proceso de creación de aplicaciones web. Establezca Implementación continua en Habilitar en la pestaña Implementación y configure la organización, el repositorio y la rama que desee.
Al habilitar la implementación continua, la creación de aplicaciones elige automáticamente el método de autenticación en función de la selección de autenticación básica y configura la aplicación y el repositorio de GitHub en consecuencia:
Configuración de la implementación de Acciones de GitHub desde el centro de implementación
Para una aplicación existente, puede empezar a trabajar rápidamente con Acciones de GitHub con el centro de implementación de App Service. Este método de llave a paso genera un archivo de flujo de trabajo de Acciones de GitHub basado en la pila de aplicaciones y lo confirma en el repositorio de GitHub.
El Centro de implementación también le permite configurar fácilmente la autenticación de OpenID Connect más segura con una identidad asignada por el usuario . Para obtener más información, consulte la opción de identidad asignada por el usuario.
Si la cuenta de Azure tiene los permisos necesarios , puede crear una identidad asignada por el usuario. De lo contrario, puede seleccionar una identidad administrada asignada por el usuario existente en el menú desplegable Identidad. Puede trabajar con el administrador de Azure para crear una identidad administrada asignada por el usuario con el rol Colaborador del sitio web.
La manera recomendada de autenticarse con Azure App Services para Acciones de GitHub es con OpenID Connect. Este enfoque es un método de autenticación que usa tokens de corta duración. La configuración de OpenID Connect con Acciones de GitHub es más compleja, pero ofrece seguridad reforzada.
Como alternativa, puede autenticarse con una identidad administrada asignada por el usuario, una entidad de servicio o un perfil de publicación.
En el procedimiento siguiente se describen los pasos para crear una aplicación de Active Directory, una entidad de servicio y credenciales federadas mediante instrucciones de la CLI de Azure. Para más información sobre cómo crear una aplicación de directorio activo, un principal de servicio y credenciales federadas en el portal Azure, consulte Conectar GitHub y Azure.
Este comando devuelve un JSON con un appId que es el client-id. Guarde el valor que se usará como secreto de GitHub de AZURE_CLIENT_ID más adelante.
Use el valor de objectId al crear credenciales federadas con Graph API y haga referencia a dicho valor como APPLICATION-OBJECT-ID.
Crear una entidad de servicio. Reemplace $appID por el valor de appId de la salida de JSON.
Este comando genera una salida JSON con un objectId diferente que se usará en el paso siguiente. El nuevo objectId es assignee-object-id.
Copie el appOwnerTenantId para usarlo como secreto de GitHub para AZURE_TENANT_ID más adelante.
az ad sp create --id $appId
Cree una asignación de roles por suscripción y objeto. De forma predeterminada, la asignación de roles se vincula a la suscripción predeterminada. Reemplace $subscriptionId por el identificador de suscripción, $resourceGroupName por el nombre del grupo de recursos, $webappName por el nombre de la aplicación web y $assigneeObjectId por el id generado. Obtenga información sobre cómo administrar suscripciones de Azure con la CLI de 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
Reemplace APPLICATION-OBJECT-ID por el appId (generado al crear la aplicación) para la aplicación de Active Directory.
Establezca un valor para CREDENTIAL-NAME al que haga referencia más adelante.
Establezca subject. GitHub define su valor en función del flujo de trabajo:
Para trabajos en el entorno de Acciones de GitHub: repo:< Organization/Repository >:environment:< Name >
En el caso de los trabajos no vinculados a un entorno, incluya la ruta de acceso de referencia para una rama o etiqueta en función de la ruta de acceso de referencia usada para desencadenar el flujo de trabajo: repo:< Organization/Repository >:ref:< ref path>. Por ejemplo, repo:n-username/ node_express:ref:refs/heads/my-branch o repo:n-username/ node_express:ref:refs/tags/my-tag.
En el caso de los flujos de trabajo desencadenados por un evento de solicitud de incorporación de cambios: 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"
]
}
Un perfil de publicación es una credencial de nivel de aplicación. Configure el perfil de publicación como secreto de GitHub.
En Azure Portal, vaya a la aplicación de App Service.
En la página Información general, seleccione Descargar perfil de publicación.
Guarde el archivo descargado. Use el contenido del archivo para crear un secreto de GitHub.
Nota:
A partir de octubre de 2020, las aplicaciones web Linux necesitan la configuración de la aplicación WEBSITE_WEBDEPLOY_USE_SCM establecer en trueantes de descargar el perfil de publicación. Este paso dejará de ser un requisito en el 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
En el ejemplo anterior, se reemplazan los marcadores de posición por su identificador de suscripción, el nombre del grupo de recursos y el nombre de la aplicación. La salida es un objeto JSON con las credenciales de asignación de roles que proporcionan acceso a la aplicación App Service similar al siguiente fragmento de código JSON. Copie este objeto JSON para más adelante.
Siempre es recomendable conceder acceso mínimo. El ámbito del ejemplo anterior se limita a la aplicación específica de App Service y no a todo el grupo de recursos.
Debe proporcionar el identificador de cliente de la aplicación, Id. de clientey id. de suscripción a la acción inicio de sesión de Azure. Estos valores se pueden proporcionar directamente en el flujo de trabajo o se pueden almacenar en secretos de GitHub y se puede hacer referencia a ellos en el flujo de trabajo. Guardar los valores como secretos de GitHub es la opción más segura.
Abra el repositorio de GitHub y vaya a Configuración>Seguridad>Secretos y variables>Acciones>Nuevo repositorio secreto.
Cree secretos para AZURE_CLIENT_ID, AZURE_TENANT_ID y AZURE_SUBSCRIPTION_ID. Use estos valores de la aplicación de Active Directory para los secretos de GitHub:
Secreto de GitHub
Aplicación de Active Directory
AZURE_CLIENT_ID
Id. de aplicación (cliente)
AZURE_TENANT_ID
Id. de directorio (inquilino)
AZURE_SUBSCRIPTION_ID
Id. de suscripción
Guarde todos los secretos, para lo que debe seleccionar Add secret (Agregar secreto).
En GitHub, examine el repositorio. Seleccione Configuración>Secretos y variables de seguridad>>Acciones>Nuevo secreto de repositorio.
Para usar las credenciales de nivel de aplicación que creó en la sección anterior, pegue el contenido del archivo de perfil de publicación descargado en el campo valor del secreto. Asigne al secreto el siguiente nombre: AZURE_WEBAPP_PUBLISH_PROFILE.
Al configurar el archivo de flujo de trabajo de GitHub más adelante, use el AZURE_WEBAPP_PUBLISH_PROFILE en la acción Implementar aplicación web de Azure. Por ejemplo:
En GitHub, examine el repositorio. Seleccione Configuración>Seguridad>Secretos y variables>Acciones>Nuevo secreto de repositorio.
Para usar credenciales de nivel de usuario que creó en la sección anterior, pegue toda la salida JSON del comando de la CLI de Azure en el campo valor del secreto. Asigne al secreto el siguiente nombre: AZURE_CREDENTIALS.
Al configurar el archivo de flujo de trabajo de GitHub más adelante, use el secreto para el creds de entrada del Azure/inicio de sesión. Por ejemplo:
Adición del archivo de flujo de trabajo al repositorio de GitHub
Un archivo YAML (.yml) en la ruta de acceso /.github/workflows/ del repositorio de GitHub define un flujo de trabajo. En esta definición se incluyen los diversos pasos y parámetros que componen el flujo de trabajo.
Como mínimo, el archivo de flujo de trabajo tendría los siguientes pasos diferenciados:
Autentíquese con App Service mediante el secreto de GitHub que creó.
Cree la aplicación web.
Implemente la aplicación web.
Para implementar el código en una aplicación de App Service, use la acción azure/webapps-deploy@v3. La acción requiere el nombre de la aplicación web en app-name y, en función de la pila de lenguaje, la ruta de acceso de un *.zip, *.war, *.jar o carpeta para implementar en package. Para obtener una lista completa de las posibles entradas para la acción de azure/webapps-deploy@v3, consulte action.yml.
En los siguientes ejemplos se muestra la parte del flujo de trabajo que compila la aplicación web en los diversos lenguajes admitidos.
Para implementar con OpenID Connect mediante la identidad administrada que configuró, use la azure/login@v1acción con las claves client-id, tenant-idy subscription-id. Haga referencia a los secretos de GitHub que creó 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
Compile e implemente una aplicación ASP.NET MVC en Azure con una entidad de servicio de Azure. En el ejemplo se usan secretos de GitHub para los valores client-id, tenant-id y subscription-id. También puede pasar estos valores directamente en la acción de inicio de sesión.
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
Compile e implemente una aplicación Java Spring en Azure con una entidad de servicio de Azure. En el ejemplo se usan secretos de GitHub para los valores client-id, tenant-id y subscription-id. También puede pasar estos valores directamente en la acción de inicio de sesión.
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'
Puede encontrar este ejemplo completo con varios trabajos para compilar e implementar.
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
La entrada publish-profile debe hacer referencia al secreto de GitHub AZURE_WEBAPP_PUBLISH_PROFILE que creó 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'
Compile e implemente una aplicación ASP.NET MVC que use NuGet y publish-profile para la autenticación.
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/'
Compile e implemente una aplicación Java Spring en Azure con un perfil de publicación de Azure. La entrada publish-profile hace referencia al secreto de AZURE_WEBAPP_PUBLISH_PROFILE que creó 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 implementar un archivo war en lugar de jar, cambie el valor de package.
Compile e implemente una aplicación de Tomcat en Azure mediante un perfil de publicación de Azure. La entrada publish-profile hace referencia al secreto de AZURE_WEBAPP_PUBLISH_PROFILE que creó 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'
Puede encontrar este ejemplo completo con varios trabajos para compilar e implementar.
Compile e implemente una aplicación Node.js en Azure con el perfil de publicación de la aplicación. La entrada publish-profile hace referencia al secreto de AZURE_WEBAPP_PUBLISH_PROFILE que creó 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 }}
Compile e implemente una aplicación Python en Azure con el perfil de publicación de la aplicación. Observe cómo la entrada publish-profile hace referencia al secreto de AZURE_WEBAPP_PUBLISH_PROFILE que creó 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 implementar con la entidad de servicio que configuró, use la acción azure/login@v1 con la clave creds y haga referencia al secreto de AZURE_CREDENTIALS que creó 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
Compile e implemente una aplicación ASP.NET MVC en Azure con una entidad de servicio de Azure. La entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó 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
Compile e implemente una aplicación Java Spring en Azure con una entidad de servicio de Azure. La entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó 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
Compile e implemente una aplicación de Tomcat en Azure mediante una entidad de servicio de Azure. La entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó 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'
Puede encontrar este ejemplo completo con varios trabajos para compilar e implementar.
Compile e implemente una aplicación Node.js en Azure con una entidad de servicio de Azure. La entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó 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
Compile e implemente una aplicación Python en Azure con una entidad de servicio de Azure. La entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó 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
¿Cómo implemento un archivo WAR mediante el complemento Maven?
En caso de configurar el proyecto de Java Tomcat con el Complemento Maven, también puede implementarlo en Azure App Service a través de este complemento. Si usa la acción de GitHub de la CLI de Azure, usa las credenciales de Azure.
Gracias a la acción de Azure Web Deploy, puede automatizar el flujo de trabajo para implementar contenedores personalizados en App Service con Acciones de GitHub. Para obtener más información sobre los pasos para implementar mediante Acciones de GitHub, consulte Implementación en un contenedor.
¿Cómo se actualiza la configuración de Tomcat después de la implementación?
En caso de que quiera actualizar la configuración de alguna de sus aplicaciones web una vez implementadas, puede usar la acción Configuración del servicio de aplicaciones.
- 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
Para obtener más información sobre esta acción y cómo usarla y configurarla, consulte el repositorio configuración de App Service.
Contenido relacionado
Consulte las referencias en flujos de trabajo y Acciones de GitHub de Azure:
