Uso do Azure Kubernetes Services para microsserviços Java com Spring Boot
Tim Kelly9 min read • Published Apr 15, 2024 • Updated Apr 15, 2024
APLICATIVO COMPLETO
Avalie esse Tutorial
Nos primórdios do desenvolvimento de software, o desenvolvimento de aplicativos consistia em bases de código monolíticas. Com desafios de dimensionamento, pontos únicos de falha e ineficiências na atualização, foi proposta uma solução. Uma abordagem modular. Uma sinfonia de aplicativos que gerenciam seus respectivos domínios em harmonia. Isso é conseguido usando microsserviços.
Os microsserviços são uma abordagem arquitetônica que promove a divisão de aplicativos em serviços menores e fracamente acoplados. Isso permite que o código do aplicativo seja fornecido em partes gerenciáveis, independentes umas das outras. Esses serviços operam de forma independente, abordando muitas das preocupações dos aplicativos monolíticos mencionadas acima.
Embora cada aplicativo tenha suas próprias necessidades, os microsserviços provaram ser uma solução viável repetidamente, como você pode ver no sucesso de empresas como a Netflix.
Neste tutorial, vamos implantar um aplicativo simples de microsserviço Java Spring Boot, hospedado no Azure Kubernetes Service (AKS). O AKS simplifica a distribuição de um cluster gerenciado Kubernetes no Azure ao transferir a sobrecarga operacional para o Azure. Exploraremos a containerização de nosso aplicativo e a configuração da comunicação entre nossas APIs, um banco de MongoDB database e o mundo externo. Você pode acessar o código completo aqui:
1 git clone https://github.com/mongodb-developer/simple-movie-microservice.git
Embora não nos aprofundemos nas melhores práticas e padrões de design de microsserviços mais avançados, esse aplicativo oferece uma abordagem simplista que permitirá que você escreva resenhas para os filmes nos dados de amostra do MongoDB, comunicando-se primeiro com a API de avaliação e esse serviço, verificando se o usuário e o filme existem. A arquitetura será assim.
Simples, certo? Exatamente! E o AKS facilita ainda mais a comunicação com outras APIs gerenciadas no serviço. Em uma arquitetura de microsserviços, os serviços precisam se descobrir dinamicamente. O próprio Kubernetes atua como um registro de serviços, onde cada serviço no cluster tem um nome único. Portanto, quando nos comunicamos com nossos outros serviços no ReviewController.java, simplesmente enviamos uma solicitação para
http://user-management-service/users/
. Neste aplicativo de demonstração, a comunicação é feita com solicitações RESTful HTTP/S, usando RestTemplate.Antes de começar, você precisará de alguns pré-requisitos para acompanhar este tutorial, incluindo:
- Uma conta doMongoDB Atlas, se você ainda não tiver uma, com um cluster pronto com os dados de amostra do MongoDB.
- O Azure CLIou você pode instalar o Azure PowerShell, mas este tutorial usa o Azure CLI. Inicie sessão e configure a ferramenta de linha de comando seguindo os passos na documentação para CLI do Azure e Azure PowerShell.
- Docker para criar imagens de contêiner de nossos microsserviços.
- Java 17.
- Maven 3.9.6.
Começando desde o início, configure um cluster do Azure Kubernetes Service (AKS).
Instale
kubectl
, a ferramenta de linha de comando do Kubernetes, por meio da CLI do Azure com o seguinte comando (talvez seja necessário fazer sudo nesse comando) ou faça download dos binários em:1 az aks install-cli
Faça login em sua conta do Azure usando a CLI do Azure:
1 az login
Crie um grupo de recursos do Azure:
1 az group create --name myResourceGroup --location northeurope
Crie um cluster AKS: Substitua
myAKSCluster
pelo nome do cluster desejado. (Isso pode levar alguns minutos).1 az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 2 --enable-addons monitoring --generate-ssh-keys
Depois de criar com êxito seu cluster AKS, você pode configurar o
kubectl
para usar seu novo cluster AKS. Recupere as credenciais do seu cluster AKS e configure kubectl
:1 az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
Crie um ACR para armazenar e gerenciar imagens de contêiner em todos os tipos de implementações do Azure:
1 az acr create --resource-group <your-resource-group> --name <your-container-registry> --sku Basic
Nota: Salve o ID do serviço do aplicativo aqui. Precisaremos dela mais tarde quando estivermos criando uma entidade de serviço.
Faça login no ACR:
1 az acr login --name <your-container-registry>
Cada um dos seus aplicativos (gerenciamento de usuários, catálogo de filmes, avaliações) tem um
Dockerfile
. Crie um .jar executando o comando mvn package
para cada aplicativo, no local do arquivo pom.xml. Dependendo da sua plataforma, as etapas a seguir são ligeiramente diferentes.Para aqueles que usam um Mac M1 , é necessário um pouco de ajuste devido à arquitetura da nossa imagem. Tal como está, os Aplicativos de Container do Azure só podem jive com imagens de contêiner do linux/amd64 . No entanto, o M1 Mac cria imagens como
arm
por padrão. Para navegar por esse soluço, aproveitaremos o Buildx, um prático plug-in do Docker. O Buildx nos permite criar e enviar imagens personalizadas para uma variedade de plataformas e arquiteturas, garantindo que nossas imagens se alinham com os requisitos do Azure.Para construir sua imagem, certifique-se de executar o seguinte comando no mesmo local que o
Dockerfile
. Repita para cada aplicativo.1 docker build -t movie-catalogue-service .
Ou você pode executar o comando a seguir na pasta simple-movie-microservice para percorrer todos os três repositórios.
1 for i in movie-catalogue reviews user-management; do cd $i; ./mvnw clean package; docker build -t $i-service .; cd -; done
Se você estiver usando um M1 Mac, use os seguintes comandos para usar o Buildx para criar suas imagens:
1 docker buildx install
Em seguida, habilite o Buildx para usar o Docker CLI:
1 docker buildx create --use
Abra um terminal e navegue até o diretório raiz do microsserviço onde o
Dockerfile
está localizado. Execute o seguinte comando para construir a imagem Docker, substituindo movie-catalogue-service
pelo nome apropriado para cada serviço.1 docker buildx build --platform linux/amd64 -t movie-catalogue-service:latest --output type=docker .
Agora, estamos prontos para marcar e enviar suas imagens. Substitua
<your-acr-name>
pelo seu nome real do ACR. Repita estes dois comandos para cada microsserviço.1 docker tag movie-catalogue-service <your-acr-name>.azurecr.io/movie-catalogue-service:latest 2 docker push <your-acr-name>.azurecr.io/movie-catalogue-service:latest
Ou execute este script no terminal, como antes:
1 ACR_NAME="<your-acr-name>.azurecr.io" 2 3 for i in movie-catalogue reviews user-management; do 4 # Tag the Docker image for Azure Container Registry 5 docker tag $i-service $ACR_NAME/$i-service:latest 6 # Push the Docker image to Azure Container Registry 7 docker push $ACR_NAME/$i-service:latest 8 done
Agora que temos nossas imagens prontas, precisamos criar arquivos YAML de implantação e serviço do Kubernetes para cada microsserviço. Vamos criar um monoarquivo para criar os objetos do Kubernetes para nossa implantação e nossos serviços. Também precisamos de um para armazenar nossos detalhes do MongoDB. É uma boa prática usar segredos para dados confidenciais, como o URI do MongoDB.
Primeiro, você precisará criar um segredo para passar com segurança a connection string do MongoDB para seus microsserviços. Em Kubernetes, os dados dentro de um objeto secreto são armazenados como cadeias de caracterescodificadas de base64. Essa codificação é usada porque permite armazenar dados binários em um formato que pode ser representado e transmitido com segurança como texto simples. Não é uma forma de criptografia ou destinado a proteger os dados, mas garante a compatibilidade com sistemas que podem não lidar bem com dados binários brutos.
Crie um segredo do Kubernetes que contenha o URI do MongoDB e o nome do banco de dados. Você codificará esses valores no formato Base64 , mas o Kubernetes os tratará como texto simples ao iniciá-los em seus pods. Você pode codificá-las com o comando bash e copiá-las para o arquivo YAML, ao lado das chaves de dados apropriadas:
1 echo -n 'your-mongodb-uri' | base64 2 echo -n 'your-database-name' | base64
1 apiVersion: v1 2 kind: Secret 3 metadata: 4 name: mongodb-secret 5 type: Opaque 6 data: 7 MONGODB_URI: <Base64 encoded MongoDB URI> 8 MONGODB_DATABASE: <Base64 encoded MongoDB database name>
Execute o seguinte comando para aplicar seus segredos:
1 kubectl apply -f mongodb-secret.yaml
Portanto, embora a codificação base64 não proteja os dados, ela os formata de uma forma segura de armazenar na API Kubernetes e fácil de consumir em seus aplicativos executados em pods.
Se o ACR for privado, você precisará garantir que o cluster Kubernetes tenha as credenciais necessárias para acessá-lo. Você pode conseguir isso criando um segredo do Kubernetes com suas credenciais de registro e, em seguida, usando esse segredo em seus sistemas.
A próxima etapa é criar uma entidade de serviço ou usar uma existente que tenha acesso ao seu ACR. Este principal de serviço precisa da função
AcrPull
atribuída para poder extrair imagens do ACR. Substitua <your-service-principal-name>
, <your-subscription-id>
, <your-resource-group-name>
e <your-acr-name>
pelos seus próprios valores. : Esse pode ser qualquer identificador exclusivo que você queira dar a esse principal de serviço. : você pode obter o ID da assinatura que está usando com az account show --query id --output tsv
. : Use o mesmo grupo de recursos em que você configurou seu AKS. : este é o registro de contêiner do Azure em que você tem suas imagens armazenadas.1 az ad sp create-for-rbac --name <your-service-principal-name> --role acrPull --scopes /subscriptions/<your-subscription-id>/resourceGroups/<your-resource-group-name>/providers/Microsoft.ContainerRegistry/registries/<your-acr-name>
Este comando gerará um JSON que se parece com isto:
1 { 2 "appId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", 3 "displayName": "<your-service-principal-name>", 4 "password": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", 5 "tenant": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" 6 }
appId
é o seu<your-service-principal-app-id>
.password
é o seu<your-service-principal-password>
.
Observação: é importante observar que o
password
é exibido apenas uma vez no momento da criação. Certifique-se de copiá-lo e proteja-o.Crie um segredo do Kubernetes com as credenciais do principal de serviço. Você pode fazer isso com o seguinte comando:
1 kubectl create secret docker-registry acr-auth \ 2 --namespace default \ 3 --docker-server=<your-acr-name>.azurecr.io \ 4 --docker-username=<your-service-principal-app-id> \ 5 --docker-password=<your-service-principal-password> \ 6 --docker-email=<your-email>
Há alguns pontos a serem observados no arquivo YAML deste tutorial, mas esses pontos não esgotam tudo o que acontece neste arquivo. Se quiser saber mais sobre como configurar seu YAML para o Kubernetes, confira a documentação para configurar objetos do Kubernetes.
- Nossas APIs serão expostas externamente. Isso significa que você poderá acessar os endpoints a partir dos endereços que receberemos quando tivermos tudo em execução. Configurando o
type: LoadBalancer
Atlas Aciona o balancer de carga do provedor de nuvem para ser provisionado automaticamente. O balancer de carga externo será configurado para rotear o tráfego para o serviço do Kubernetes , que por sua vez roteia o tráfego para os pods apropriados com base no seletor do serviço. - A seção
containers:
define um único container denominadomovie-catalogue-service
, usando uma imagem especificada por<your-container-registry>/movie-catalogue-service:latest
. containerPort: 8080
expõe a porta 8080 dentro do container para comunicação de rede.- As variáveis de ambiente
MONGODB_URI
eMONGODB_DATABASE
são definidas usando valores de segredos (mongodb-secret
), aumentando a segurança ao não codificar informações confidenciais. imagePullSecrets: - name: acr-auth
permite que o Kubernetes se autentique em um registro de container privado para extrair a imagem especificada, usando o segredo que acabamos de criar.
1 --- 2 apiVersion: apps/v1 3 kind: Deployment 4 metadata: 5 name: movie-catalogue-service-deployment 6 spec: 7 replicas: 1 8 selector: 9 matchLabels: 10 app: movie-catalogue-service 11 template: 12 metadata: 13 labels: 14 app: movie-catalogue-service 15 spec: 16 containers: 17 - name: movie-catalogue-service 18 image: <your-container-registry>/movie-catalogue-service:latest 19 ports: 20 - containerPort: 8080 21 env: 22 - name: MONGODB_URI 23 valueFrom: 24 secretKeyRef: 25 name: mongodb-secret 26 key: MONGODB_URI 27 - name: MONGODB_DATABASE 28 valueFrom: 29 secretKeyRef: 30 name: mongodb-secret 31 key: MONGODB_DATABASE 32 imagePullSecrets: 33 - name: acr-auth 34 --- 35 apiVersion: v1 36 kind: Service 37 metadata: 38 name: movie-catalogue-service 39 spec: 40 selector: 41 app: movie-catalogue-service 42 ports: 43 - protocol: TCP 44 port: 80 45 targetPort: 8080 46 type: LoadBalancer 47 ---
Lembre-se de que antes de aplicar seus arquivos YAML do Kubernetes, verifique se o cluster do Kubernetes tem acesso ao seu ACR. Você pode configurar isso concedendo ao AKS a função ACRPull em seu ACR:
1 az aks update -n <your-AKS-Cluster> -g <your-resource-group> --attach-acr <your-ACR>
Substitua
<your-AKS-Cluster>
, <your-resource-group>
e <your-ACR>
pelo nome do cluster AKS, nome do grupo de recursos do Azure e nome do ACR, respectivamente.Aplique o arquivo YAML com
kubectl
:1 kubectl apply -f all-microservices.yaml
Depois de implementado, pode levar alguns minutos para que o LoadBalancer seja provisionado e os endereços IP externos sejam atribuídos. Você pode verificar o status dos seus serviços com:
1 kubectl get services
Procure os endereços IP externos dos seus serviços e use-os para acessar seus microsserviços.
Após a implementação, certifique-se de que seus serviços estejam em execução:
1 kubectl get pods
Acesse seus serviços com base no tipo de serviço Kubernetes que você definiu (por exemplo, LoadBalancer em nosso caso) e realize seus testes.
Você pode testar se o endpoint está em execução com o comando CURL:
1 curl -X POST http://<ReviewAPI-External-IP>/reviews \ 2 -H "Content-Type: application/json" \ 3 -d '{"movieId": "573a1391f29313caabcd68d0", "userId": "59b99db5cfa9a34dcd7885b8", "rating": 4}'
E essa avaliação deverá aparecer em seu banco de dados. Você pode verificar com um simples:
1 curl -X GET http://<ReviewAPI-External-IP>/reviews
Viva!
À medida que encerramos este tutorial, fica claro que adotar a arquitetura de microsserviços, especialmente quando emparelhados com o poder do Kubernetes e do Azure Kubernetes Service (AKS), pode melhorar significativamente a escalabilidade, a manutenção e a flexibilidade de implantação dos aplicativos. Por meio da implementação prática de um aplicativo simples de microsserviço usando o Java Spring Boot no AKS, demonstramos as etapas e considerações envolvidas para dar vida a uma arquitetura de microsserviços na nuvem.
Principais conclusões:
- Abordagem modular: a transição da arquitetura monolítica para a arquitetura de microsserviços facilita uma abordagem modular para o desenvolvimento de aplicativos, permitindo o desenvolvimento, a implantação e o dimensionamento independentes de serviços.
- Implantação simplificada do Kubernetes: o AKS abstrai grande parte da complexidade envolvida no gerenciamento de um cluster do Kubernetes, oferecendo um caminho simplificado para a implantação de microsserviços em escala.
- Comunicação entre serviços : a utilização do DNS interno do Kubernetes para a descoberta de serviços simplifica a comunicação entre serviços dentro de um cluster, tornando as interações de microsserviços mais eficientes e confiáveis .
- Práticas recomendadas de segurança e configuração: o tutorial sublinhou a importância do uso de segredos do Kubernetes para configurações confidenciais e do Registro de Container do Azure para gerenciar e implantar imagens de container com segurança.
- Expor serviços externamente: ao definir serviços como
type: LoadBalancer
, vimos como expor microsserviços externamente, permitindo fácil acesso e integração com outros aplicativos e serviços.
A simplicidade e a robustez do Kubernetes, combinadas com a escalabilidade do AKS e a modularidade dos microsserviços, fornecem aos desenvolvedores as ferramentas necessárias para criar aplicativos complexos que são resilientes e adaptáveis. Se este tutorial foi útil, saiba mais sobre o que você pode fazer com o MongoDB e o Azure em nosso Centro do Desenvolvedor.
Você está pronto para começar a construir com Atlas no Azure? Comece hoje mesmo gratuitamente a utilizar oMongoDB Atlas no Azure Marketplace.
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.