Implantação de aplicações .NET no Azure: guia completo

Introdução

O Microsoft Azure oferece um ecossistema rico e de alto desempenho para hospedar suas aplicações .NET. Graças à integração nativa entre .NET e Azure, você pode implantar suas aplicações com facilidade e aproveitar escalabilidade automática, alta disponibilidade e segurança reforçada. Este guia apresenta as diferentes opções de implantação e as melhores práticas para otimizar suas aplicações .NET na nuvem.

Pré-requisitos

Antes de começar, certifique-se de ter:

• Uma conta Azure (você pode criar uma conta gratuita em azure.microsoft.com)
• O SDK do .NET instalado na sua máquina de desenvolvimento
• Azure CLI ou Azure PowerShell instalado (opcional, mas recomendado)
• Visual Studio 2022 ou Visual Studio Code com a extensão do Azure
• Git para controle de versão

Azure App Service para aplicações web .NET

O Azure App Service é a solução PaaS (Platform as a Service) ideal para hospedar suas aplicações web ASP.NET e ASP.NET Core.

Criação de um App Service pelo portal do Azure

1. Faça login no Portal do Azure
2. Clique em “Criar um recurso” > “Web” > “App Service”
3. Preencha as informações básicas:
   • Grupo de recursos: crie um novo ou use um existente
   • Nome do aplicativo: deve ser único em todo o Azure
   • Publicar: selecione “Código”
   • Pilha de runtime: escolha ”.NET 6” (ou a versão que você utiliza)
   • Sistema operacional: Windows ou Linux
   • Região: escolha a mais próxima dos seus usuários
   • Plano do App Service: selecione um plano existente ou crie um novo
4. Clique em “Revisar + criar” e depois em “Criar”

Implantação pelo Visual Studio

1. Abra sua solução no Visual Studio
2. Clique com o botão direito no projeto web e selecione “Publicar”
3. Escolha “Azure” como destino
4. Selecione “Azure App Service” e depois a instância que você acabou de criar
5. Configure os parâmetros de implantação e clique em “Publicar”

Implantação via Azure DevOps

# azure-pipelines.yml
trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

variables:
  buildConfiguration: 'Release'
  webAppName: 'votre-app-service'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: '6.x'

- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: true

- task: AzureWebApp@1
  inputs:
    azureSubscription: 'votre-connexion-azure'
    appName: '$(webAppName)'
    package: '$(Build.ArtifactStagingDirectory)/*.zip'

Configuração do ambiente

Use as configurações do aplicativo para configurar sua aplicação sem recompilação:

1. No portal do Azure, acesse seu App Service
2. Em “Configuração” > “Configurações do aplicativo”, adicione suas variáveis de ambiente
3. Por exemplo, para uma cadeia de conexão com um banco de dados:
   • Nome: ConnectionStrings__DefaultConnection
   • Valor: sua cadeia de conexão

Azure Functions para microsserviços serverless

O Azure Functions permite executar trechos de código sem gerenciar a infraestrutura subjacente.

Criação de uma Function App

// Function App simples que responde a requisições HTTP
public static class HttpExample
{
    [FunctionName("HttpExample")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
        ILogger log)
    {
        log.LogInformation("C# HTTP trigger function processed a request.");

        string name = req.Query["name"];
        
        string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
        dynamic data = JsonConvert.DeserializeObject(requestBody);
        name = name ?? data?.name;
        
        string responseMessage = string.IsNullOrEmpty(name)
            ? "Cette fonction HTTP a été exécutée avec succès. Passez un nom dans la requête pour obtenir un message personnalisé."
            : $"Bonjour, {name}. Cette fonction HTTP a été exécutée avec succès.";
            
        return new OkObjectResult(responseMessage);
    }
}

Implantação de Azure Functions

Pelo Visual Studio

1. Crie um projeto Azure Functions
2. Desenvolva suas funções
3. Clique com o botão direito no projeto > “Publicar”
4. Escolha Azure como destino
5. Selecione ou crie uma Function App

Usando o Azure CLI

# Fazer login no Azure
az login

# Criar um grupo de recursos (se necessário)
az group create --name MonGroupeDeRessources --location francecentral

# Criar uma Function App
az functionapp create --resource-group MonGroupeDeRessources --consumption-plan-location francecentral --runtime dotnet --functions-version 4 --name MonAppDeFonctions --storage-account monstockage

# Implantar o código
func azure functionapp publish MonAppDeFonctions

Conteinerização com Docker e Azure Container Registry

A conteinerização das suas aplicações .NET oferece portabilidade e consistência entre os ambientes.

Criação de um Dockerfile para ASP.NET Core

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["MonApp.csproj", "./"]
RUN dotnet restore "MonApp.csproj"
COPY . .
RUN dotnet build "MonApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MonApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MonApp.dll"]

Criação e uso do Azure Container Registry (ACR)

# Criar um registro de contêineres
az acr create --resource-group MonGroupeDeRessources --name monregistre --sku Basic

# Fazer login no registro
az acr login --name monregistre

# Construir a imagem Docker
docker build -t monapp:v1 .

# Marcar a imagem com a tag para o ACR
docker tag monapp:v1 monregistre.azurecr.io/monapp:v1

# Enviar a imagem para o ACR
docker push monregistre.azurecr.io/monapp:v1

Implantação no Azure App Service com contêineres

# Habilitar o acesso de administrador para o registro
az acr update -n monregistre --admin-enabled true

# Obter as credenciais do registro
az acr credential show -n monregistre

# Criar um App Service Plan que oferece suporte a contêineres
az appservice plan create --resource-group MonGroupeDeRessources --name MonPlanAppService --is-linux --sku B1

# Criar um App Service que usa o contêiner
az webapp create --resource-group MonGroupeDeRessources --plan MonPlanAppService --name MonAppWeb --deployment-container-image-name monregistre.azurecr.io/monapp:v1

# Configurar as credenciais do registro
az webapp config container set --name MonAppWeb --resource-group MonGroupeDeRessources --docker-custom-image-name monregistre.azurecr.io/monapp:v1 --docker-registry-server-url https://monregistre.azurecr.io --docker-registry-server-user monregistre --docker-registry-server-password <mot-de-passe>

Azure Kubernetes Service (AKS) para aplicações .NET

O AKS é ideal para aplicações complexas que exigem orquestração avançada de contêineres.

Implantação de uma aplicação .NET no AKS

1. Crie um cluster AKS:

az aks create --resource-group MonGroupeDeRessources --name MonClusterAKS --node-count 2 --enable-addons monitoring --generate-ssh-keys

2. Conecte-se ao cluster:

az aks get-credentials --resource-group MonGroupeDeRessources --name MonClusterAKS

3. Crie um arquivo de implantação do Kubernetes (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: monapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: monapp
  template:
    metadata:
      labels:
        app: monapp
    spec:
      containers:
      - name: monapp
        image: monregistre.azurecr.io/monapp:v1
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: monapp
spec:
  type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: monapp

4. Implante a aplicação no AKS:

kubectl apply -f deployment.yaml

5. Verifique se o serviço está acessível:

kubectl get services monapp

Bancos de dados do Azure para aplicações .NET

Azure SQL Database com Entity Framework Core

1. Crie um banco de dados Azure SQL pelo portal do Azure

2. Configure a cadeia de conexão na sua aplicação:

// appsettings.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=tcp:monserveur.database.windows.net,1433;Database=maBaseDeDonnees;User ID=monutilisateur;Password=monMotDePasse;Encrypt=true;Connection Timeout=30;"
  }
}

3. Use o Entity Framework Core para se conectar:

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    
    // ...
}

Azure Cosmos DB para NoSQL

// Configuração do cliente Cosmos DB
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<CosmosClient>(serviceProvider => {
        var configuration = serviceProvider.GetRequiredService<IConfiguration>();
        var cosmosDbSection = configuration.GetSection("CosmosDb");
        var endpoint = cosmosDbSection["Endpoint"];
        var key = cosmosDbSection["Key"];
        
        return new CosmosClient(endpoint, key);
    });
    
    services.AddSingleton<IDocumentRepository, CosmosDbRepository>();
}

CI/CD para aplicações .NET com GitHub Actions

Workflow do GitHub Actions para App Service

# .github/workflows/azure-webapps-dotnet.yml
name: .NET Core CI/CD pour Azure Web App

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  AZURE_WEBAPP_NAME: votre-app-service
  AZURE_WEBAPP_PACKAGE_PATH: '.'
  DOTNET_VERSION: '6.0.x'

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    
    - name: Configurer .NET Core
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: ${{ env.DOTNET_VERSION }}
    
    - name: Restaurer les dépendances
      run: dotnet restore
    
    - name: Build
      run: dotnet build --configuration Release --no-restore
    
    - name: Test
      run: dotnet test --no-restore --verbosity normal
    
    - name: Publish
      run: dotnet publish -c Release -o ${{env.AZURE_WEBAPP_PACKAGE_PATH}}/myapp
    
    - name: Déployer sur Azure Web App
      uses: azure/webapps-deploy@v2
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{env.AZURE_WEBAPP_PACKAGE_PATH}}/myapp

Monitoramento e diagnósticos

Application Insights para monitoramento

1. Crie um recurso Application Insights no portal do Azure

2. Integre o Application Insights na sua aplicação:

// Program.cs (.NET 6)
var builder = WebApplication.CreateBuilder(args);

// Adicionar o Application Insights
builder.Services.AddApplicationInsightsTelemetry();

// ...

var app = builder.Build();

3. Adicione logs personalizados:

// Em um controller ou serviço
public class MonController : Controller
{
    private readonly ILogger<MonController> _logger;
    
    public MonController(ILogger<MonController> logger)
    {
        _logger = logger;
    }
    
    public IActionResult Index()
    {
        _logger.LogInformation("La page d'accueil a été visitée");
        return View();
    }
}

4. Visualize as métricas no portal do Azure Application Insights

Segurança das aplicações .NET no Azure

Uso do Azure Key Vault

1. Crie um cofre de chaves no portal do Azure

2. Conceda as permissões à sua aplicação:

az keyvault set-policy --name MonCoffre --object-id <object-id-de-votre-app> --secret-permissions get list

3. Integre o Key Vault na sua aplicação:

// Program.cs
var builder = WebApplication.CreateBuilder(args);

// Adicionar a configuração do Azure Key Vault
builder.Configuration.AddAzureKeyVault(
    new Uri($"https://{builder.Configuration["KeyVault:VaultName"]}.vault.azure.net/"),
    new DefaultAzureCredential());

Configuração do Azure AD B2C para autenticação

// Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAdB2C"));

// ...

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

Otimização de custos

Dicas para reduzir os custos no Azure

1. Escolher o nível de preço adequado:

   • Use os níveis Free e Shared para desenvolvimento
   • Considere Basic/Standard para produção de pequeno a médio porte

2. Escalar automaticamente:

   • Configure o autoscaling de acordo com as necessidades

   az monitor autoscale create --resource-group MonGroupeDeRessources --resource monappservice --resource-type "Microsoft.Web/sites" --name autoscale-config --min-count 1 --max-count 5 --count 1

3. Usar instâncias reservadas para economias de longo prazo

4. Ativar o Azure Cost Management para monitorar e otimizar os gastos

5. Limpar regularmente os recursos não utilizados

Boas práticas para .NET no Azure

1. Arquitetura cloud-native:

   • Projete para resiliência e escalabilidade
   • Use arquiteturas serverless quando apropriado

2. Configuração externalizada:

   • Armazene os parâmetros no Azure App Configuration ou no Key Vault
   • Use variáveis de ambiente para configurações específicas

3. Monitoramento completo:

   • Integre o Application Insights desde o início
   • Configure alertas para as métricas críticas

4. Testes automatizados:

   • Inclua testes de carga específicos para o Azure
   • Use ambientes de teste/pré-produção

5. Infrastructure as Code (IaC):

   • Utilize Azure Resource Manager (ARM) ou Terraform

   // exemplo de template ARM
   {
     "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
     "contentVersion": "1.0.0.0",
     "parameters": {
       "appServiceName": {
         "type": "string",
         "metadata": {
           "description": "Nom de l'App Service"
         }
       }
     },
     "resources": [
       {
         "type": "Microsoft.Web/serverfarms",
         "apiVersion": "2020-06-01",
         "name": "[parameters('appServiceName')]",
         "location": "[resourceGroup().location]",
         "sku": {
           "name": "B1",
           "tier": "Basic"
         }
       }
     ]
   }

Conclusão

O Azure oferece um ecossistema rico e integrado para suas aplicações .NET, permitindo cobrir todo o ciclo de vida de desenvolvimento. Ao combinar os serviços do Azure com as boas práticas de desenvolvimento .NET, você pode criar aplicações robustas, de alto desempenho e escaláveis.

As ferramentas e os serviços apresentados neste guia são apenas o começo do que o Azure pode oferecer aos desenvolvedores .NET. Não hesite em explorar mais e combinar diferentes serviços para atender às necessidades específicas da sua aplicação.

Recursos adicionais

• Documentação oficial do Azure para .NET
• Exemplos de código .NET no Azure
• Arquitetura de referência para .NET no Azure
• Cloud Adoption Framework
• Azure Friday (vídeos)