[pt-br] Publicar uma aplicação .NET 6/ .NET Core no Azure AKS (Azure Kubernetes Service)

Nesse tutorial, não entrarei em detalhes sobre as tecnologias abordadas, apenas quero deixar essa receita de "bolo" para quem precisar de algo prático.

Esse conhecimento foi adquirido em uma recente formação que tive na empresa que trabalho atualmente, e gostaria de deixar esses "rascunhos" salvos para consultas no futuro.

Para publicar uma aplicação .NET 6 no Azure AKS (Azure Kubernetes Service), siga os seguintes passos:

  1. Certifique-se de ter uma conta do Azure ativa e configurada. Se você ainda não tem uma conta, pode criar uma no site do Azure.

  2. Acesse o portal do Azure e crie um novo cluster do AKS. Para isso, vá até o menu "Create a resource" e selecione "Kubernetes Service" na lista de opções. Siga as instruções na tela para configurar o cluster, incluindo o nome do cluster, a região, a versão do Kubernetes e os recursos de nó.

  3. Depois que o cluster for criado, você precisará instalar o Azure CLI (Command Line Interface) em sua máquina local. O Azure CLI é um conjunto de ferramentas de linha de comando que permite gerenciar recursos do Azure de forma automatizada. Você pode baixar o Azure CLI aqui: docs.microsoft.com/en-us/cli/azure/install-..

  4. Depois de instalar o Azure CLI, abra o terminal e execute o comando "az login" para fazer login na sua conta do Azure. Será solicitado que você acesse o portal do Azure e autorize o Azure CLI a acessar sua conta.

  5. Agora, vamos criar um arquivo de configuração do Kubernetes, chamado de "manifest.yaml". Este arquivo descreve os componentes da sua aplicação, como pods, serviços e volumes. Você pode encontrar exemplos de manifestos no site do Kubernetes (kubernetes.io/docs/concepts/workloads/contr..).

  6. Depois de criar o manifesto, execute o comando "kubectl apply -f manifest.yaml" para aplicar as configurações do manifesto no cluster do AKS. Isso criará os recursos descritos no manifesto, como pods, serviços e volumes.

  7. Por fim, você precisará expor o seu serviço para que ele possa ser acessado externamente. Para isso, você pode usar o comando "kubectl expose" para criar um recurso "LoadBalancer" que fará o balanceamento de carga para o seu serviço.

  8. Depois que o recurso "LoadBalancer" for criado, você pode obter o endereço IP externo do seu serviço executando o comando "kubectl get service". Isso lhe dará acesso à sua aplicação publicada no AKS.

Se você não tem os arquivos de configuração, abaixo deixo alguns exemplos de arquivos de configuração do Kubernetes para uma aplicação .NET 6. Eles são baseados na estrutura padrão de um manifesto, que inclui três principais tipos de recursos:

  • deployment
  • service
  • ingress.

Exemplo de Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 80

Exemplo de Service:

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  type: LoadBalancer
  selector:
    app: myapp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80

Exemplo de Ingress:

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: myapp-ingress
spec:
  rules:
  - host: myapp.example.com
    http:
      paths:
      - backend:
          serviceName: myapp-service
          servicePort: 80

Lembre-se de que esses são apenas exemplos básicos. É importante ler a documentação do Kubernetes para obter mais informações sobre como criar arquivos de configuração de maneira eficiente.

Deixarei também um exemplo simples de Dockerfile configurado para uma aplicação .NET 6

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

# Copiar csproj e restaurar dependências
COPY *.csproj ./
RUN dotnet restore

# Copiar todo o resto e construir
COPY . ./
RUN dotnet publish -c Release -o out

# Build da imagem runtime
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app
COPY --from=build-env /app/out .
ENTRYPOINT ["dotnet", "MyApp.dll"]

Este Dockerfile utiliza duas imagens base do Docker: uma para o ambiente de build e outra para o runtime. A primeira imagem, mcr.microsoft.com/dotnet/sdk:6.0, é utilizada para construir a aplicação e gerar os arquivos binários. A segunda imagem, mcr.microsoft.com/dotnet/aspnet:6.0, é utilizada para executar a aplicação e expor suas funcionalidades por meio de uma porta HTTP.

O Dockerfile começa copiando os arquivos .csproj e restaurando as dependências da aplicação. Em seguida, copia todos os arquivos restantes e constrói a aplicação utilizando o comando "dotnet publish". Por fim, copia os arquivos binários gerados para a imagem runtime e define o ponto de entrada da aplicação com o comando "ENTRYPOINT".