Tutorial: Compilar e implementar desde el código fuente en Azure Container Apps

En este artículo se muestra cómo compilar e implementar una aplicación en Azure Container Apps desde el código fuente de la máquina en el lenguaje de programación preferido.

En este tutorial, hará lo siguiente:

• Cree una aplicación web simple.
• Cree un Dockerfile asociado para la aplicación.
• Cree una imagen a partir del código compilado e insértela en un registro de contenedor.
• Use la identidad administrada para acceder de forma segura al registro de contenedor.
• Implemente el contenedor en Azure Container Apps.
• Vea la aplicación en un explorador para comprobar la implementación.

Requisitos previos

Para completar este proyecto, necesita los siguientes elementos:

Requisito	Instructions
Cuenta de Azure	Si no tiene ninguna cuenta, cree una gratuita. Necesita el permiso Colaborador o Propietario en la suscripción de Azure para continuar. Consulte Asignación de roles de Azure mediante Azure Portal para obtener más información.
CLI de Azure	Instale la CLI de Azure o actualice a la última versión. La Azure Developer CLI (comandos azd) está disponible a través de la CLI de Azure.

En función de su elección de lenguaje, es posible que también tenga que instalar el entorno de ejecución, el SDK y otras dependencias adecuados.

C#

Instale el SDK de .NET.

Java

• Instale el kit de desarrollo de Java.

• Instalación de Apache Maven.

JavaScript

Instale Node.js.

Python

Instale Python.

Creación de la aplicación local

En los pasos siguientes se muestran el código y las dependencias necesarios para compilar una aplicación de ejemplo que se va a implementar en Azure Container Apps.

Nota:

Si desea usar otro lenguaje distinto de los enumerados, escriba el siguiente mensaje en el modelo de IA preferido.

Antes de enviar el mensaje, reemplace <LANGUAGE> por el lenguaje que prefiera.

Generate the simplest possible "hello world" web server in idiomatic <LANGUAGE>.

Make sure to include any dependencies required for the application to run locally and in production. 

1. Cree y ejecute el código fuente.

   C#

   Cree un nuevo proyecto de C#.

   dotnet new webapp --name MyAcaDemo --language C#
   

   Cambie a la carpeta MyAcaDemo.

   cd MyAcaDemo
   

   Abra Program.cs en un editor de código y reemplace el contenido por el código siguiente.

   public class Program
   {
       public static void Main(string[] args)
       {
           CreateHostBuilder(args).Build().Run();
       }
   
       public static IHostBuilder CreateHostBuilder(string[] args) =>
           Host.CreateDefaultBuilder(args)
               .ConfigureWebHostDefaults(webBuilder =>
               {
                   webBuilder.UseStartup<Startup>();
                   webBuilder.UseUrls("http://*:8080");
               });
   }
   

   La implementación de la clase Program con este código crea la base de una aplicación web. A continuación, cree una clase responsable de devolver una página web como respuesta.

   En la misma carpeta, cree un nuevo archivo denominado Startup.cs y escriba el código siguiente.

   public class Startup
   {
       public void ConfigureServices(IServiceCollection services)
       {
       }
   
       public void Configure(IApplicationBuilder app)
       {   
           app.UseRouting();
   
           app.UseEndpoints(endpoints =>
           {
               endpoints.MapGet("/", async context =>
               {
                   await context.Response.WriteAsync("Hello World!");
               });
           });
       }
   }
   

   Ahora, cuando se realiza una solicitud a la aplicación web, se devuelve el texto "Hola mundo". Para comprobar que el código se está ejecutando correctamente en la máquina local, compile el proyecto en la configuración de versión.

   dotnet build -c Release
   

   A continuación, ejecute la aplicación para comprobar que el código se ha implementado correctamente.

   dotnet run --configuration Release
   

   Java

   Cree una nueva aplicación Java capturando primero la aplicación de inicio de Spring Boot mediante el comando siguiente.

   curl https://start.spring.io/starter.zip -d dependencies=web -d name=MyAcaDemo -d artifactId=MyAcaDemo -d baseDir=MyAcaDemo -o MyAcaDemo.zip
   

   Si no tiene instalado el comando unzip, puede instalarlo ahora.

   sudo apt-get update && sudo apt-get install unzip
   

   Ahora puede descomprimir el paquete en una carpeta denominada MyAcaDemo.

   unzip MyAcaDemo.zip -d MyAcaDemo
   

   Al descomprimir este paquete, crea una estructura de carpetas anidada donde una carpeta denominada MyAcaDemo reside dentro de una carpeta externa denominada MyAcaDemo.

   Use el siguiente comando para cambiar a la carpeta MyAcaDemo correcta.

   cd MyAcaDemo/MyAcaDemo
   

   Abra esta carpeta en un editor de código para que pueda agregar y editar algunos archivos.

   En la carpeta src/main/java/com/example/MyAcaDemo/, cree un archivo denominado MyAcaDemoController.java y escriba el código siguiente.

   package com.example.MyAcaDemo;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class MyAcaDemoController {
       @GetMapping("/")
       public String hello() {
           return "Hello, World!";
       }
   }
   

   En la carpeta MyAcaDemo, cree un archivo denominado pom.xml y agregue el código siguiente.

   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>com.example</groupId>
       <artifactId>MyAcaDemo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>MyAcaDemo</name>
       <description>Demo project for Spring Boot</description>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>3.1.0</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <properties>
           <java.version>17</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
               <version>3.1.0</version>
               <configuration>
                   <mainClass>com.example.MyAcaDemo.MyAcaDemoApplication</mainClass>
               </configuration>
           </plugin>
           </plugins>
       </build>
   </project>
   

   Ejecute el comando siguiente para comprobar las compilaciones del proyecto sin errores.

   mvn clean package -DskipTests
   

   Una vez que tenga una compilación correcta, ejecute el siguiente comando para asegurarse de que la aplicación se ejecuta correctamente en el equipo.

   mvn spring-boot:run
   

   JavaScript

   Cree una carpeta denominada MyAcaDemo para almacenar los archivos de la aplicación de demostración.

   mkdir MyAcaDemo
   

   A continuación, cambie a la carpeta MyAcaDemo.

   cd MyAcaDemo
   

   Use el comando siguiente para generar los archivos básicos para una aplicación de Node.js.

   npm init -y
   

   Abra esta carpeta en un editor de código y cree un archivo denominado index.js con el código siguiente.

   const http = require('http');
   
   const server = http.createServer((req, res) => {
       res.writeHead(200, { 'Content-Type': 'text/html' });
       res.end('<html>Hello World!</html>');
   });
   
   server.listen(8080, () => {
       console.log('Server running at http://localhost:8080/');
   });
   

   Ahora puede ejecutar el siguiente comando para asegurarse de que la aplicación se ejecuta correctamente en el equipo.

   node index.js
   

   Python

   Cree una carpeta con el nombre MyAcaDemo.

   mkdir MyAcaDemo
   

   Cambie a la carpeta MyAcaDemo.

   cd MyAcaDemo
   

   Instale Flask mediante el comando siguiente.

   pip install flask
   

   La aplicación de ejemplo se basa en el marco de Flask. La necesita instalada localmente para que pueda comprobar que la aplicación se ejecuta correctamente en la máquina antes de intentar implementarla en la nube.

   Cree un nuevo archivo denominado app.py y escriba el código siguiente.

   from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def hello_world():
       return '<html>Hello World!</html>'
   
   if __name__ == '__main__':
       app.run()
   

   Este código crea un servidor web básico que devuelve Hola mundo..

   En la misma carpeta, cree un nuevo archivo denominado requirements.txt y escriba el código siguiente.

   Flask
   gunicorn
   

   Este archivo indica al entorno de ejecución de Python que use el marco web de Flask y el servidor web gunicorn para hospedar la aplicación de ejemplo.

   Ejecute el siguiente comando para comprobar que la aplicación funciona correctamente.

   python3 app.py
   

   Una vez que compruebe que la aplicación funciona según lo previsto, puede detener el servidor local y pasar a crear un Dockerfile para que pueda implementar la aplicación en Container Apps.

2. En la carpeta MyAcaDemo, cree un archivo denominado Dockerfile y agregue el código siguiente.

   C#

   FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
   WORKDIR /src
   COPY . .
   RUN dotnet publish -c Release -o /app/publish
   
   FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
   WORKDIR /app
   COPY --from=build /app/publish .
   EXPOSE 8080
   ENTRYPOINT ["dotnet", "MyAcaDemo.dll"]
   

   Java

   FROM maven:3.8.4-openjdk-17 AS build
   WORKDIR /app
   COPY pom.xml .
   COPY src ./src
   RUN mvn clean package -DskipTests
   
   FROM openjdk:17-jdk-alpine
   WORKDIR /app
   COPY --from=build /app/target/MyAcaDemo-0.0.1-SNAPSHOT.jar /app/MyAcaDemo.jar
   EXPOSE 8080
   ENTRYPOINT ["java", "-jar", "MyAcaDemo.jar"]
   

   JavaScript

   FROM node:18
   WORKDIR /usr/src/app
   COPY ./ . 
   RUN npm install
   EXPOSE 3000
   CMD ["node", "index.js"]
   

   Python

   FROM python:3.9-slim
   WORKDIR /app
   COPY . /app
   RUN pip install --no-cache-dir -r requirements.txt
   EXPOSE 8080
   ENV FLASK_APP=app.py
   CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]
   

   Ahora que tiene el código y un Dockerfile listo, puede implementar la aplicación en Azure Container Apps.

Creación de recursos de Azure

1. Inicie sesión en Azure desde la CLI con el comando siguiente. Para completar el proceso de autenticación, asegúrese de seguir todas las indicaciones.

   az login
   

2. Instale o actualice la extensión de Azure Container Apps para la CLI.

   az extension add --name containerapp --upgrade
   

   Nota:

   Si recibe errores sobre los parámetros que faltan al ejecutar comandos az containerapp, asegúrese de tener instalada la última versión de la extensión de Azure Container Apps.

3. Ahora que la configuración de la CLI de Azure está completa, puede definir un conjunto de variables de entorno.

   Antes de ejecutar el siguiente comando, revise los valores proporcionados.

   La ubicación se configura como Centro de EE. UU., pero puede cambiar a una ubicación más cercana si lo prefiere.

   LOCATION="CentralUS"
   RESOURCE_GROUP="my-demo-group"
   IDENTITY_NAME="my-demo-identity"
   ENVIRONMENT="my-demo-environment"
   REGISTRY_NAME="mydemoregistry$(openssl rand -hex 4)"
   CONTAINER_APP_NAME="my-demo-app"
   

   El comando mydemoregistry$(openssl rand -hex 4) genera una cadena aleatoria que se usará como nombre del registro de contenedor. Los nombres del Registro deben ser únicos globalmente, por lo que esta cadena ayuda a garantizar que los comandos se ejecuten correctamente.

4. Cree un grupo de recursos para organizar los servicios relacionados con la implementación de la aplicación contenedora.

   az group create \
     --name $RESOURCE_GROUP \
     --location $LOCATION \
     --output none
   

5. Cree una identidad administrada asignada por el usuario y obtenga su identificador con los siguientes comandos.

   En primer lugar, cree la identidad administrada.

   az identity create \
       --name $IDENTITY_NAME \
       --resource-group $RESOURCE_GROUP \
       --output none
   

   Ahora, establezca el identificador de identidad en una variable para su uso posterior.

   IDENTITY_ID=$(az identity show \
     --name $IDENTITY_NAME \
     --resource-group $RESOURCE_GROUP \
     --query id \
     --output tsv)
   

6. Cree un entorno de Container Apps para hospedar la aplicación mediante el comando siguiente.

   az containerapp env create \
       --name $ENVIRONMENT \
       --resource-group $RESOURCE_GROUP \
       --location $LOCATION \
       --mi-user-assigned $IDENTITY_ID \
       --output none
   

7. Cree una instancia de Azure Container Registry (ACR) en el grupo de recursos. El registro almacena la imagen de contenedor.

   az acr create \
     --resource-group $RESOURCE_GROUP \
     --name $REGISTRY_NAME \
     --sku Basic \
     --output none
   

8. Asigne la identidad administrada asignada por el usuario a la instancia del registro de contenedor con el comando siguiente.

   az acr identity assign \
     --identities $IDENTITY_ID \
     --name $REGISTRY_NAME \
     --resource-group $RESOURCE_GROUP \
     --output none
   

Compilación e inserción de la imagen en un registro

Compile e inserte la imagen de contenedor en la instancia del registro de contenedor con el comando siguiente.

az acr build \
    -t $REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld" \
    -r $REGISTRY_NAME .

Este comando aplica la etiqueta helloworld a la imagen de contenedor.

Creación de la aplicación de contenedor

Cree la aplicación contenedora con el comando siguiente.

az containerapp create \
  --name $CONTAINER_APP_NAME \
  --resource-group $RESOURCE_GROUP \
  --environment $ENVIRONMENT \
  --image $REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld" \
  --target-port 8080 \
  --ingress external \
  --user-assigned $IDENTITY_ID \
  --registry-identity $IDENTITY_ID \
  --registry-server $REGISTRY_NAME.azurecr.io \
  --query properties.configuration.ingress.fqdn

Este comando agrega el rol acrPull a la identidad administrada asignada por el usuario, por lo que puede extraer imágenes del registro de contenedor.

En la tabla siguiente se describen los parámetros usados por este comando.

Parámetro	Valor	Descripción
name	$CONTAINER_APP_NAME	El nombre de la aplicación contenedora.
resource-group	$RESOURCE_GROUP	El grupo de recursos en el que se implementa la aplicación contenedora.
environment	$ENVIRONMENT	Entorno en el que se ejecuta la aplicación contenedora.
image	$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"	Imagen de contenedor que se va a implementar, incluido el nombre y la etiqueta del Registro.
target-port	8080	Coincide con el puerto al que escucha la aplicación para las solicitudes.
ingress	external	Hace que la aplicación contenedora sea accesible desde la red pública de Internet.
user-assigned	$IDENTITY_ID	Identidad administrada asignada por el usuario para la aplicación contenedora.
registry-identity	registry-identity	Identidad usada para acceder al registro de contenedor.
registry-server	$REGISTRY_NAME.azurecr.io	Dirección del servidor del registro de contenedor.
query	properties.configuration.ingress.fqdn	Filtra la salida a solo el nombre de dominio completo (FQDN) de la aplicación.

Una vez completado este comando, devuelve la dirección URL de la nueva aplicación web.

Comprobación de la implementación

Copie la dirección URL de la aplicación en un explorador web. Una vez iniciada la aplicación contenedora, devuelve Hola mundo..

Dado que es la primera vez que se accede a la aplicación, la aplicación puede tardar unos instantes en devolver una respuesta.

Limpieza de recursos

Si no va a usar los recursos de Azure creados en este tutorial, puede quitarlos con un solo comando. Antes de ejecutar el comando, hay un paso siguiente en esta serie de tutoriales que muestra cómo realizar cambios en el código y actualizar la aplicación en Azure.

Si ha terminado y desea quitar todos los recursos de Azure creados en este tutorial, elimine el grupo de recursos con el comando siguiente.

az group delete --name aca-demo

Sugerencia

¿Tiene problemas? Háganoslo saber en GitHub abriendo una incidencia en el repositorio de Azure Container Apps.

Pasos siguientes

A continuación, continúe para obtener información sobre cómo actualizar la aplicación contenedora que ha creado.

Actualizar una aplicación contenedora implementada desde el código fuente