Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Idiomaschevron-right
Javachevron-right

Uso do Azure Kubernetes Services para microsserviços Java com Spring Boot

Tim Kelly9 min read • Published Apr 15, 2024 • Updated Apr 15, 2024
AzureSpringKubernetesJava
APLICATIVO COMPLETO
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty

Introdução

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:
1git 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.
O diagrama de arquitetura do aplicativo de microsserviço.
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.

Pré-requisitos

Antes de começar, você precisará de alguns pré-requisitos para acompanhar este tutorial, incluindo:

Configurar um cluster do Azure Kubernetes Service

Começando desde o início, configure um cluster do Azure Kubernetes Service (AKS).

Instalar o kubectl e criar um cluster 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:
1az aks install-cli
Faça login em sua conta do Azure usando a CLI do Azure:
1az login
Crie um grupo de recursos do Azure:
1az group create --name myResourceGroup --location northeurope
Crie um cluster AKS: Substitua myAKSCluster pelo nome do cluster desejado. (Isso pode levar alguns minutos).
1az aks create --resource-group myResourceGroup --name myAKSCluster --node-count 2 --enable-addons monitoring --generate-ssh-keys

Configure o kubectl para usar seu cluster AKS

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:
1az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Criar um Registro de Contêiner do Azure (ACR)

Crie um ACR para armazenar e gerenciar imagens de contêiner em todos os tipos de implementações do Azure:
1az 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:
1az acr login --name <your-container-registry>

Contêinerize seu aplicativo de microsserviços

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.

Crie a imagem do Docker (não M1 Mac)

Para construir sua imagem, certifique-se de executar o seguinte comando no mesmo local que o Dockerfile. Repita para cada aplicativo.
1docker 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.
1for i in movie-catalogue reviews user-management; do cd $i; ./mvnw clean package; docker build -t $i-service .; cd -; done

Crie a imagem do Docker (M1 Mac)

Se você estiver usando um M1 Mac, use os seguintes comandos para usar o Buildx para criar suas imagens:
1docker buildx install
Em seguida, habilite o Buildx para usar o Docker CLI:
1docker 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.
1docker buildx build --platform linux/amd64 -t movie-catalogue-service:latest --output type=docker .

Marcar e empurrar

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.
1docker tag movie-catalogue-service <your-acr-name>.azurecr.io/movie-catalogue-service:latest
2docker push <your-acr-name>.azurecr.io/movie-catalogue-service:latest
Ou execute este script no terminal, como antes:
1ACR_NAME="<your-acr-name>.azurecr.io"
2
3for 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
8done

Implemente seus microsserviços no AKS

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.

Criar um segredo do Kubernetes para 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:
1echo -n 'your-mongodb-uri' | base64
2echo -n 'your-database-name' | base64
1apiVersion: v1
2kind: Secret
3metadata:
4 name: mongodb-secret
5type: Opaque
6data:
7 MONGODB_URI: <Base64 encoded MongoDB URI>
8 MONGODB_DATABASE: <Base64 encoded MongoDB database name>
Execute o seguinte comando para aplicar seus segredos:
1kubectl 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.

Autorizar acesso ao ACR

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çãoAcrPull 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.
1az 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:
1kubectl 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>

Crie arquivos YAML de sistema e serviço do Kubernetes

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çãocontainers: define um único container denominado movie-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 ambienteMONGODB_URI e MONGODB_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---
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5 name: movie-catalogue-service-deployment
6spec:
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---
35apiVersion: v1
36kind: Service
37metadata:
38 name: movie-catalogue-service
39spec:
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:
1az 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

Aplique o arquivo YAML com kubectl:
1kubectl apply -f all-microservices.yaml

Acesse seus serviços

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:
1kubectl 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:
1kubectl 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:
1curl -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:
1curl -X GET http://<ReviewAPI-External-IP>/reviews
Viva!

Conclusão

À 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.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Artigo

Usar o Atlas Search do Java


Jul 14, 2023 | 13 min read
Tutorial

Gerador de lista de reprodução alimentada por IA: criando visualizações personalizadas com aprendizagem profunda4j e MongoDB


Oct 25, 2024 | 14 min read
Tutorial

Java encontra Queryable Encryption: desenvolvendo um aplicativo de conta bancária seguro


Oct 08, 2024 | 14 min read
Artigo

Driver Java: migrando do 4.11 a 5.0


Mar 01, 2024 | 3 min read
Sumário