Tutorial: Compilar e implantar do código-fonte nos Aplicativos de Contêiner do Azure

Este artigo mostra como criar e implantar um aplicativo nos Aplicativos de Contêiner do Azure a partir do código-fonte em seu computador em sua linguagem de programação preferida.

Neste tutorial, você:

• Crie um aplicativo Web simples.
• Crie um Dockerfile associado para seu aplicativo.
• Crie uma imagem do código compilado e envie-a por push para um registro de contêiner.
• Use a identidade gerenciada para acessar com segurança o registro de contêiner.
• Implante seu contêiner nos Aplicativos de Contêiner do Azure.
• Exiba seu aplicativo em um navegador para verificar a implantação.

Pré-requisitos

Para concluir este projeto, você precisa dos seguintes itens:

Requisito	Instruções
Conta do Azure	Se você não tiver, crie uma conta gratuita. Você precisa da permissão de Colaborador ou Proprietário na assinatura do Azure para continuar. Consulte Atribuir funções do Azure usando o portal do Azure para obter detalhes.
CLI do Azure	Instale a CLI do Azure ou atualize para a versão mais recente. O Azure Developer CLI (comandos azd) está disponível por meio da CLI do Azure.

Dependendo da sua escolha de idioma, talvez você também precise instalar o runtime apropriado, o SDK e outras dependências.

C#

Instale o SDK do .NET.

Java

• Instale o Java Development Kit.

• Instale o Apache Maven.

JavaScript

Instale o Node.js.

Python

Instale o Python.

Criar o aplicativo local

As etapas a seguir mostram o código e as dependências necessárias para criar um aplicativo de exemplo para implantar nos Aplicativos de Contêiner do Azure.

Observação

Se você quiser usar outro idioma diferente dos listados, insira a solicitação a seguir em seu modelo de IA preferido.

Antes de enviar a solicitação, substitua <LANGUAGE> pelo idioma de sua escolha.

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. Crie e execute seu código-fonte.

   C#

   Crie um novo projeto em C#.

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

   Altere para a pasta MyAcaDemo.

   cd MyAcaDemo
   

   Abra Program.cs em um editor de código e substitua o conteúdo pelo código a seguir.

   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");
               });
   }
   

   Implementar a classe Program com esse código cria a base de um aplicativo Web. Em seguida, crie uma classe responsável por retornar uma página da Web como resposta.

   Na mesma pasta, crie um novo arquivo nomeado Startup.cs e insira o código a seguir.

   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!");
               });
           });
       }
   }
   

   Agora, quando uma solicitação é feita ao seu aplicativo Web, o texto "Olá, Mundo!" é retornado. Para verificar se o código está sendo executado corretamente no computador local, crie seu projeto na configuração de versão.

   dotnet build -c Release
   

   Em seguida, execute seu aplicativo para verificar se o código foi implementado corretamente.

   dotnet run --configuration Release
   

   Java

   Crie um novo aplicativo Java buscando primeiro o aplicativo Spring Boot inicial usando o comando a seguir.

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

   Se você não tiver o comando unzip instalado, poderá instalá-lo agora.

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

   Agora você pode descompactar o pacote em uma pasta chamada MyAcaDemo.

   unzip MyAcaDemo.zip -d MyAcaDemo
   

   À medida que você descompacta esse pacote, ele cria uma estrutura de pasta aninhada em que uma pasta chamada MyAcaDemo reside dentro de uma pasta externa chamada MyAcaDemo.

   Use o comando a seguir para alterar para a pasta MyAcaDemo correta.

   cd MyAcaDemo/MyAcaDemo
   

   Abra essa pasta em um editor de código para que você possa adicionar e editar alguns arquivos.

   Na pasta src/main/java/com/example/MyAcaDemo/, crie um arquivo nomeado MyAcaDemoController.java e insira o código a seguir.

   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!";
       }
   }
   

   Na pasta MyAcaDemo, crie um arquivo nomeado pom.xml e adicione o código a seguir.

   <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>
   

   Execute o comando a seguir para verificar os builds do projeto sem erros.

   mvn clean package -DskipTests
   

   Depois de ter um build bem-sucedido, execute o comando a seguir para garantir que o aplicativo seja executado corretamente em seu computador.

   mvn spring-boot:run
   

   JavaScript

   Crie uma pasta chamada MyAcaDemo para armazenar os arquivos do aplicativo de demonstração.

   mkdir MyAcaDemo
   

   Em seguida, altere para a pasta MyAcaDemo.

   cd MyAcaDemo
   

   Use o comando a seguir para gerar os arquivos básicos para um aplicativo Node.js.

   npm init -y
   

   Abra essa pasta em um editor de código e crie um arquivo nomeado index.js com o código a seguir.

   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/');
   });
   

   Agora você pode executar o comando a seguir para garantir que o aplicativo seja executado corretamente em seu computador.

   node index.js
   

   Python

   Crie uma pasta chamada MyAcaDemo.

   mkdir MyAcaDemo
   

   Altere para a pasta MyAcaDemo.

   cd MyAcaDemo
   

   Instale o Flask usando o comando a seguir.

   pip install flask
   

   O aplicativo de exemplo é baseado na estrutura do Flask. Você precisa dele instalado localmente para verificar se seu aplicativo é executado corretamente em seu computador antes de tentar implantá-lo na nuvem.

   Crie um novo arquivo nomeado app.py e insira o código a seguir.

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

   Esse código cria um servidor Web básico que retorna Olá, Mundo!.

   Na mesma pasta, crie um novo arquivo nomeado requirements.txt e insira o código a seguir.

   Flask
   gunicorn
   

   Este arquivo instrui o runtime do Python a usar a estrutura web do Flask e o servidor Web gunicorn para hospedar o aplicativo de exemplo.

   Execute o comando a seguir para verificar se o aplicativo está funcionando corretamente.

   python3 app.py
   

   Depois de verificar se o aplicativo funciona conforme o esperado, você pode parar o servidor local e passar a criar um Dockerfile para que possa implantar o aplicativo em Aplicativos de Contêiner.

2. Na pasta MyAcaDemo, crie um arquivo nomeado Dockerfile e adicione o conteúdo a seguir.

   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"]
   

   Agora que você tem seu código e um Dockerfile prontos, você pode implantar seu aplicativo nos Aplicativos de Contêiner do Azure.

Criar recursos do Azure

1. Entre no Azure da CLI com o comando a seguir. Para concluir o processo de autenticação, siga todos os prompts.

   az login
   

2. Instale ou atualize a extensão aplicativos de contêiner do Azure para a CLI do Azure.

   az extension add --name containerapp --upgrade
   

   Observação

   Se você receber erros sobre parâmetros ausentes ao executar comandos az containerapp, certifique-se de ter a versão mais recente da extensão aplicativos de contêiner do Azure instalada.

3. Agora que a configuração da CLI do Azure está concluída, você pode definir um conjunto de variáveis de ambiente.

   Antes de executar o comando a seguir, examine os valores fornecidos.

   O local é configurado como EUA Central, mas você pode alterar para um local mais próximo, se preferir.

   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"
   

   O comando mydemoregistry$(openssl rand -hex 4) gera uma cadeia de caracteres aleatória a ser usada como o nome do registro de contêiner. Os nomes do Registro devem ser globalmente exclusivos, portanto, essa cadeia de caracteres ajuda a garantir que seus comandos sejam executados com êxito.

4. Crie um grupo de recursos para organizar os serviços relacionados à implantação do aplicativo de contêiner.

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

5. Crie uma identidade gerenciada atribuída pelo usuário e obtenha sua ID com os comandos a seguir.

   Primeiro, crie a identidade gerenciada.

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

   Agora defina o identificador de identidade em uma variável para uso posterior.

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

6. Crie um ambiente de Aplicativos de Contêiner para hospedar seu aplicativo usando o comando a seguir.

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

7. Crie uma instância do Registro de Contêiner do Azure (ACR) em seu grupo de recursos. O registro armazena sua imagem de contêiner.

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

8. Atribua sua identidade gerenciada atribuída pelo usuário à instância do registro de contêiner com o comando a seguir.

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

Compilar e enviar a imagem por push para um registro

Crie e envie sua imagem de contêiner por push para a instância do registro de contêiner com o comando a seguir.

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

Esse comando aplica a marca helloworld à sua imagem de contêiner.

Criar seu aplicativo de contêiner

Crie seu aplicativo de contêiner com o comando a seguir.

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

Esse comando adiciona a função acrPull à sua identidade gerenciada atribuída pelo usuário, para que ela possa efetuar pull de imagens do registro de contêiner.

A tabela a seguir descreve os parâmetros usados por este comando.

Parâmetro	Valor	Descrição
name	$CONTAINER_APP_NAME	O nome do aplicativo de contêiner.
resource-group	$RESOURCE_GROUP	O grupo de recursos no qual seu aplicativo de contêiner é implantado.
environment	$ENVIRONMENT	O ambiente no qual seu aplicativo de contêiner é executado.
image	$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"	A imagem de contêiner a ser implantada, incluindo o nome e a marca do Registro.
target-port	8080	Corresponde à porta que seu aplicativo está escutando para solicitações.
ingress	external	Torna seu aplicativo de contêiner acessível pela Internet pública.
user-assigned	$IDENTITY_ID	A identidade gerenciada atribuída pelo usuário para seu aplicativo de contêiner.
registry-identity	registry-identity	A identidade usada para acessar o registro de contêiner.
registry-server	$REGISTRY_NAME.azurecr.io	O endereço do servidor do registro de contêiner.
query	properties.configuration.ingress.fqdn	Filtra a saída apenas para o FQDN (nome de domínio totalmente qualificado) do aplicativo.

Depois que esse comando for concluído, ele retornará a URL do novo aplicativo Web.

Verificar a implantação

Copie a URL do aplicativo em um navegador da Web. Depois que o aplicativo de contêiner é iniciado, ele retorna Olá, Mundo!.

Como essa é a primeira vez que o aplicativo é acessado, pode levar alguns instantes para que o aplicativo retorne uma resposta.

Limpar os recursos

Se você não usar os recursos do Azure criados neste tutorial, poderá removê-los com um único comando. Antes de executar o comando, há uma próxima etapa nesta série de tutoriais que mostra como fazer alterações no código e atualizar seu aplicativo no Azure.

Se você terminar e quiser remover todos os recursos do Azure criados neste tutorial, exclua o grupo de recursos com o comando a seguir.

az group delete --name aca-demo

Dica

Está enfrentando problemas? Deixe-nos saber sobre GitHub abrindo um problema no repositório dos Aplicativos de Contêiner do Azure.

Próximas etapas

Em seguida, continue aprendendo a atualizar o aplicativo de contêiner que você criou.

Atualizar um aplicativo de contêiner implantado do código-fonte