Devprime | Documentação – DigitalOcean

Deployment: Droplet

Mon, 01 Jan 0001 00:00:00 +0000

Introdução

A plataforma Devprime acelera a produtividade do desenvolvedor de software, oferecendo um projeto completo de arquitetura de software, componentes com comportamentos inteligentes, aceleradores para a implementação de código e atualizações com novos recursos.

Durante este artigo, usaremos um microsserviço com uma regra de negócio relacionada a pedidos, um banco de dados no MongoDB. Demonstraremos os passos para criar o microsserviço, os serviços de hospedagem na DigitalOcean e, em seguida, as configurações necessárias para disponibilizá-lo usando o plano gratuito.

Checklist e preparação do ambiente local inicial:

Abra uma conta na plataforma Devprime e adquira uma licença (Developer/Enterprise).
Instale uma versão atualizada do .NET (Linux, macOS e Windows).
Instale e/ou atualize o Visual Studio Code e/ou o Visual Studio 2023 Community / Professional / Enterprise.
Instale e/ou atualize o Docker (Para Windows, utilize o WSL2).
Inicialize os contêineres do MongoDB e RabbitMQ utilizando o Docker e adicione a fila ‘orderevents’ usando o RabbitMQ.
Instale e ative a versão mais nova do Devprime CLI.
Crie uma pasta para os seus projetos e defina as permissões de leitura e gravação.
Consulte o artigo “Criando o primeiro microsserviço” para explorar os primeiros passos na plataforma Devprime.
Abra uma conta de Cloud na DigitalOcean
(Your $200 Credit, You’ve been invited to DigitalOcean! Sign up and get a $200, 60-day credit to try our products. Spend $25 after your credit expires and whoever referred you will get $25 in credit!)

Criando um microsserviço para utilizar no exemplo

O primeiro passo é criar um novo microsserviço para utilizá-lo como modelo para publicação na nuvem. O nome deste microsserviço será definido como “ms-order”, e utilizaremos o banco de dados MongoDB e a stream do RabbitMQ, conforme demonstrado no comando abaixo.

Crie uma pasta chamada \do e entre nela.
Execute o Devprime CLI para criar o primeiro microsserviço:
dp new ms-order --stream rabbitmq --state MongoDB
Adicione uma regra de negócio de exemplo “Order” com o comportamento de uma classe Aggregate Root e outra classe entity. Entre na pasta \do\ms-order e digite:
dp marketplace order
Ative o acelerador do Devprime CLI para construir implementações do microsserviço, como repositório, serviço de aplicação, exposição de APIs e comunicação entre as camadas da aplicação:
dp init

Após a criação do novo microsserviço, entre na pasta do projeto “ms-order” e você já pode visualizar todas as implementações pelo Visual Studio Code conforme demonstrado no artigo relacionado à criação do primeiro microsserviço.

Para abrir no Visual Studio Code:
code .

Neste momento não utilizaremos o RabbitMQ e vamos desabilitar nas configurações do Adapter de Stream por meio do arquivo de configuração em src\App\appsettings.json.

Entre na nova pasta ms-order e abra pelo Visual Studio Code
code src\App\appsettings.json
Localize a chave “DevPrime_Stream” e na opção “Enable” coloque “false”.
Altere o Handler “OrderCreated” comentando a linha “Dp.Stream.Send(destination, eventName, eventData);” para que não haja envio de evento pelo Stream.

Abra o Handler pelo Visual Studio Code
src\Core\Application\EventHandlers\Order\OrderCreatedEventHandler.cs

Executando o novo microsserviço Order

Os passos anteriores habilitam um microsserviço pronto para produção com as regras de negócio obtidas pelo marketplace da Devprime.

Permissão chmod no Linux, macOS
Para executar o arquivo “.sh” no (Linux, macOS) é necessário adicionar a permissão abaixo tornando o script executável.
chmod +x run.sh

Inicie o microsserviço executando um dos scripts abaixo:
.\run.ps1 (Windows) ou ./run.sh (Linux, macOS)

O microsserviço pode ser executado localmente nos ambientes Linux, macOS e Windows conforme o exemplo abaixo:

Ao acessar a API do microsserviço ms-order já temos uma “OpenAPI” implementada.

Acessando o arquivo de configuração do microsserviço

No ambiente local, você pode editar, se necessário, configurações e credenciais da aplicação no arquivo src/App/appsettings.json, como os dados de acesso ao MongoDB e ao RabbitMQ utilizados no projeto.

Para abrir no Visual Studio Code:
code src/App/appsettings.json

Criando um novo Droplet e MongoDB na DigitalOcean

O próximo passo é criar um novo Droplet utilizando como base a imagem “Ubuntu 23.10 x64” escolhendo a configuração básica de 1 CPU e 512 MB de memória RAM. Uma característica interessante nessa máquina virtual da DigitalOcean é a velocidade de provisionamento, estando já disponível em segundos.

Durante a criação lembre de ativar a opção “Add improved metrics monitoring and alerting (free)” para habilitar uma melhor visualização das metricas.

Você tem a opção de implantar serviços diretamente em seu Droplet, porém, como a DigitalOcean oferece alguns outros recursos gerenciados e para efeitos dessa demonstração, nós criaremos uma instância do MongoDB.

Abaixo é possível visualizar o resumo do dashboard na DigitalOcean com os três serviços criados (Droplet, MongoDB) e disponíveis para utilização.

O próximo passo é você obter as credenciais e connection strings do MongoDB “db-mongodb-nyc1-demo” para adicionar em seu arquivo de configuração no microsserviço.

Depois localize o item DevPrime_State e em connection adicione os dados de conexão do banco de dados db-mongo-nyc1-demo.

Abra as configurações
code src\App\appsettings.json

    "DevPrime_State": [
    {
      "enable": "true",
      "alias": "State1",
      "type": "db",
      "dbtype": "mongodb",
      "connection": "mongodb://mongoadmin:LltF8Nx*yo@localhost:27017",
      "timeout": "5",
      "retry": "2",
      "dbname": "ms-order",
      "isssl": "true",
      "durationofbreak": "45"
    }
  ],

Nesse momento, você pode executar novamente a aplicação e efetuar um post utilizando a API. Se as credenciais estiverem corretas, já estará acessando o banco de dados.

Instalando .NET Runtime ou SDK no Droplet na DigitalOcean

Uma aplicação baseada na plataforma .NET pode ser executada no Linux, macOS e Windows. Temos a opção de instalar apenas o Runtime ou escolher o SDK quando você desejar efetuar um build dentro do próprio ambiente da máquina virtual (DROPLET).

Neste artigo, estamos adotando a opção do Runtime. Para isso, basta acessar o portal da DigitalOcean, no terminal, e/ou utilizar uma ferramenta SSH ou Putty no Windows.

1
2

sudo apt-get update && \
  sudo apt-get install -y aspnetcore-runtime-8.0

Instalar .NET SDK ou .NET Runtime no Ubuntu

Exportando microsserviço e publicando na DigitalOcean

Efetuaremos um build do microsserviço localmente e, posteriormente, enviaremos utilizando um cliente FTP qualquer. Conectamos no FTP utilizando o protocolo SFTP na porta 22, utilizando o usuário “root” e a senha informada na criação do Droplet.

Antes de publicar, alteraremos a porta padrão utilizada no arquivo de configuração. Para isso, localize o item “DevPrime_Web” e, em URL, mantenha apenas o valor "url": "http://*:80".

Abra as configurações:
code src\App\appsettings.json

Agora, entre na pasta raiz do projeto e execute o comando publish para que o .NET exporte uma versão publicável utilizando o .NET Runtime na pasta de saída output no parâmetro -o.

Execute o comando:
dotnet publish .\src\App\App.csproj -c Release -o output

Entre no droplet pelo terminal usando SSH e crie uma pasta na raiz:
/devprime

Utilize o FTP para enviar o conteúdo da pasta local ms-order/output para a pasta de destino /devprime.

No terminal execute a aplicação dentro da pasta /devprime:
dotnet App.dll

Acessando o microsserviço pela internet pública

Ao utilizar uma Droplet, a implementação deixa todas as portas abertas. Como configuramos a URL “http://*:80” com a porta 80 no adaptador de Web, você já pode acessar diretamente pelo IP do Droplet. Para utilizar SSL, é necessário configurar um domínio para o IP do Droplet e utilizar um Nginx com Let’s Encrypt, por exemplo, para gerar um certificado.

Acesse o seu Droplet e obtenha o IP público para acessar por HTTP apenas, por exemplo, http://127.0.0.1, onde 127.0.0.1 será o seu IP do Droplet. Ao final do teste pare a sua aplicação para continuar no próximo passo.

Configurando o microsserviço como serviço no Linux

Um recurso importante ao trabalhar com sua aplicação dentro de um ambiente como Droplet / máquina virtual é configurar a aplicação como serviço para garantir que ela continue executando mesmo se o ambiente for reiniciado.

Abra o nano para adicionar o código do serviço devprime:
sudo nano /etc/systemd/system/devprime.service

Adicione o conteúdo abaixo e saia salvando.

[Unit]
Description=Order Microservice
After=network.target

[Service]
WorkingDirectory=/devprime
ExecStart=/usr/bin/dotnet /devprime/App.dll
Restart=always
# Define o tempo limite de inatividade (em segundos)
TimeoutStopSec=30
RestartSec=5

[Install]
WantedBy=multi-user.target

Reinicie o daemon:
sudo systemctl daemon-reload
Habilite o novo serviço devprime:
sudo systemctl enable devprime
Iniciando o serviço. Nesse momento, você já pode acessar pela Web novamente:
sudo systemctl start devprime
Verificando o status:
sudo systemctl status devprime
Opcional para reiniciar o serviço quando necessário:
sudo systemctl restart devprime
Acompanhando os logs do microsserviço:
sudo journalctl -f -u devprime
Opcional, caso não apresente logs no item 7:
sudo systemctl restart systemd-journald

Nesse momento, você já pode executar um cURL internamente e confirmar que o serviço está rodando. Você pode, inclusive, reiniciar o Droplet e testar novamente a conectividade interna e externa validando que o serviço iniicou sozinho.
curl -X GET http://127.0.0.1:80

Adicionando um Certificado SSL Usando Nginx

Para utilizar o HTTPS, é necessário ter um domínio configurado e apontando para o IP do seu Droplet. Esse domínio pode estar configurado dentro da DigitalOcean em MANAGE > Networking > Domains ou externamente. Neste guia, utilizaremos um subdomínio chamado “do.devprime.io”.

É importante lembrar que o Nginx será executado nas portas 80/443. Por isso, mudaremos nosso microserviço para a porta 5000, pois o acesso a ele será feito pelo Nginx internamente e não mais diretamente exposto.

Abra as configurações do seu projeto e altere o item URL para "url": "http://*:5000". Você pode fazer isso no projeto original conforme passos anteriores e republicar via FTP ou editar o appsettings.json dentro do Droplet.
nano appsettings.json
Reinicie o microserviço.
sudo systemctl restart devprime
Instalando o Nginx no Droplet.
sudo apt update && sudo apt install nginx
Verificando o status.
sudo systemctl status nginx
Tornando o Nginx um Service.
sudo systemctl enable nginx
Instalando Certbot e o plugin Nginx.
sudo apt update && sudo apt install certbot
sudo apt install python3-certbot-nginx
Criando certificado SSL Let’s Encrypt. Não execute antes de validar a propagação do seu DNS para o IP do droplet. Lembre de modificar o nome do domínio nos itens abaixo.
sudo certbot certonly --nginx -d do.devprime.io --email your-email@your-domain.com

Utilize o seu domínio no Nginx.
sudo nano /etc/nginx/sites-available/do.devprime.io

server {
    listen 80;
    server_name do.devprime.io;

    location / {
        proxy_pass http://localhost:5000;  # Porta interna da sua aplicação
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection keep-alive;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

server {
    listen 443 ssl;
    server_name do.devprime.io;

    ssl_certificate /etc/letsencrypt/live/do.devprime.io/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/do.devprime.io/privkey.pem;

    location / {
        proxy_pass http://localhost:5000;  # Porta interna da sua aplicação
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection keep-alive;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Crie um link simbólico.
sudo ln -s /etc/nginx/sites-available/do.devprime.io /etc/nginx/sites-enabled/
Valide a configuração do Nginx.
sudo nginx -t
Reinicialize o Nginx.
sudo systemctl restart nginx
Acesse novamente a url pública do site porém utilizando https ou utilize o comando
abaixo para verificar os detalhes da conexão lembrando de alterar a url. O retorno do log demosntra a utilização do SSL Let’s Encrypt.
curl -v https://do.devprime.io

* processing: https://do.devprime.tech
* Connected to do.devprime.io (x.x.x.x) port 443
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN: server accepted http/1.1
* Server certificate:
*  subject: CN=do.devprime.tech
*  start date: Apr 10 15:28:12 2024 GMT
*  expire date: Jul  9 15:28:11 2024 GMT
*  subjectAltName: host "do.devprime.io" matched cert's "do.devprime.io"
*  issuer: C=US; O=Let's Encrypt; CN=R3
*  SSL certificate verify ok.
* using HTTP/1.1
> GET / HTTP/1.1
> Host: do.devprime.io
> User-Agent: curl/8.2.1
< HTTP/1.1 200 OK
< Server: nginx/1.24.0 (Ubuntu)
< Connection: keep-alive
<div style='text-align:center;padding:10px;margin:10px;color:#512da8'>
    <h1>Welcome to DevPrime! </h1>
    <p>Microservice ms-order : 57f36e89-2b14-490f-81b2-a46a814830bf</p>
    <p><a href='/swagger/index.html'>Go to OpenApi</a></p>

Edite o crontab e ative a renovação automática do certificado SSL Let’s Encrypt.
crontab -e
1

0 0 * * * /usr/bin/certbot renew --quiet
Listando o crontab ativos.
1 2

crontab -l sudo ls /etc/cron.d/
Ativando o firewall.
Neste exemplo, você pode ativar o firewall utilizando o The Uncomplicated Firewall (UFW) disponível no Linux, liberando as portas 80/443/22 seguindo os passos listados.
1 2 3 4 5 6 7 8 9 10 11

# Habilitar ufw allow http ufw allow https ufw allow ssh ufw enable # Status ufw status verbose # Desligar ufw disable

Considerações Finais

Durante este artigo, você aprendeu como implantar um microserviço desenvolvido utilizando a tecnologia da plataforma Devprime em um Droplet Linux da DigitalOcean. Demonstramos um passo a passo básico que consiste basicamente em instalar o runtime do .NET e copiar o projeto compilado. As outras configurações são recursos adicionais do Linux para uma melhor experiência na execução da sua aplicação.

Em um ambiente produtivo, é altamente recomendável a utilização de um cofre para as credenciais e uma estratégia robusta de DevOps para orquestrar toda a publicação automaticamente.

Para saber mais:

Implantanndo um microsserviço Devprime no DigitalOcean Kubernetes (DOKS)

Deployment: Kubernetes (DOKS)

Mon, 01 Jan 0001 00:00:00 +0000

Introdução

A plataforma Devprime acelera a produtividade do desenvolvedor de software, oferecendo um projeto completo de arquitetura de software, componentes com comportamentos inteligentes, aceleradores para implementação de código e atualizações com novos recursos.

Neste artigo, abordaremos o uso do serviço Kubernetes (DOKS) da DigitalOcean, uma plataforma de cloud que oferece diversos recursos para o desenvolvedor de software utilizar nas aplicações.

Nós utilizaremos dois microsserviços com uma regra de negócio relacionada a pedidos e outra a pagamentos utilizando o banco de dados MongoDB gerenciado pela DigitalOcean. Demonstraremos os passos para criar o microsserviço, os serviços de cloud na DigitalOcean como o Kubernetes (DOKS), Container Registry, MongoDB e implantaremos o RabbitMQ no Kubernetes, em seguida, as configurações iniciais necessárias.

Checklist e preparação do ambiente inicial

Abra uma conta na plataforma Devprime e adquira uma licença (Developer/Enterprise).
Instale uma versão atualizada do .NET (Linux, macOS e Windows).
Instale e/ou atualize o Visual Studio Code e/ou o Visual Studio 2023 Community / Professional / Enterprise.
Instale e/ou atualize o Docker (Linux, macOS e Windows) (Para Windows, utilize o WSL2).
Inicialize localmente os containers do MongoDB e RabbitMQ no Docker e adicione a fila ‘orderevents’ e ‘paymentevents’ no RabbitMQ.
Instale e ative a versão mais nova do Devprime CLI.
Crie uma pasta local para os seus projetos e defina as permissões de leitura e gravação.
Consulte o artigo “Criando o primeiro microsserviço” para explorar os primeiros passos na plataforma Devprime.
Abra uma conta de Cloud na DigitalOcean (Your $200 Credit, You’ve been invited to DigitalOcean! Sign up and get a $200, 60-day credit to try our products. Spend $25 after your credit expires and whoever referred you will get $25 in credit!).

Primeiros passos

Neste artigo, utilizaremos um projeto com dois Microsserviços utilizando comunicação assíncrona, sendo o primeiro Order e o segundo Payment que você pode optar por criar do zero ou utilizando o exemplo no GitHub.

a) Execute um clone do projeto no GitHub:
git clone https://github.com/devprime/devprime-microservices-order-payment.git

b) Acesse a pasta clonada e verifique a pasta inicial com os itens Order e Payment. Cada pasta desta tem um microsserviço desenvolvido com a plataforma Devprime e pronto para utilização.
cd devprime-microservices-order-payment
git remote remove origin

c) Execute o comando dp stack para aplicar atualização e a sua licença Devprime:
dp stack

d) Execute cada microsserviço em uma aba do terminal para testar localmente utilizando os arquivos .\run.ps1 no Windows ou run.sh no Linux e macOS. Aplique a permissão chmod no Linux, macOS.
chmod +x run.sh

Inicie o microsserviço executando um dos scripts abaixo:
.\run.ps1 (Windows) ou ./run.sh (Linux, macOS)

/ms-order
/ms-payment

Com os microsserviços rodando efetue um post na API do microsserviço order e acompanhe o processamento no microsserviço payment conforme descrito no artigo sobre comunicação assíncrona entre microsserviços.

Criando um cluster Kubernetes (DOKS), Container Registry e MongoDB na DigitalOcean

Acesse o seu portal na DigitalOcean e no menu Kubernetes, entre na opção Create Cluster para iniciar o procedimento de criação e em node plan escolha o tamanho apropriado ao seu cenário, defina a quantidade de instâncias e avance com o processo. Execute o mesmo procedimento com o Container Registry e em Database com MongoDB criando os serviços iniciais para utilização nesse artigo.

Na imagem abaixo é apresentado uma visão dos primeiros serviços criados MongoDB e Kubernetes.

Após criar o cluster do MongoDB é fundamental acessar o item Connection String e copiar para utilizarmos na configuração nos microsserviços (order/payment). Copie toda a string de conexão e certifique que a mesma está com o usuário e a senha.

O cluster Kubernetes foi noemado como ““do-k8s-nyc1-demo” para utilização nesse artigo. No item marketplace você tem alguns recursos interessantes para implantação no cluster usando 1-Click Apps como NGINX Ingress Controller, Cert-Manager, OpenEBS NFS Provisioner, Kubernetes Monitoring Stack.

Para publicar containers no Kubernetes, nós utilizaremos o Container Registry que nesse attigo está nomeado como “dp-registry-nyc3”. Copie nesse momento a url apresentada, pois utilizaremos mais a frente no momento de criação da imagem do container.

Agora é necessário seguir um passo importante realizando o vinculo do seu Cluster Kubernetes com o Container Registry para facilitar o acesso aos containeres dentro do cluster. No portal do seu Ckuster Kubernetes, entre em Settings e depois entre na opção “DigitalOcean Container Registry Integration” e selecione o Container Registry.

Instalando ferramentas para utilização no Kubernetes

Nós utilizaremos algumas ferramentas para integração com o Kubernetes como o kubectl, que é o CLI do Kubernetes, Helm, ferramenta para instalar pacotes no Kubernetes, K9S ferramenta para visualizar o cluster, Stern, ferramenta para visualizar logs no Kubernetes, doctl, DigitalOcean’s command-line tool e Docker.

Após instalar o CLI doctl, é fundamental seguir os procedimentos de configuração do mesmo para ativar o acesso na DigitalOcean e habilitar as operações como obteção de credenciais do Container Registry e do Kubernetes.

Obtendo acesso ao Kubernetes

As credenciais de acesso ao Cluster do Kubernetes podem ser obtidas pelo portal ou utilizando o CLI doctl, conforme faremos durante esse artigo.

Obtendo as credenciais de acesso ao Cluster ao confirmar será salvo no ambiente local “.kube/config”. Copie esse comando diretamente do portal com o Guid do seu cluster.
doctl kubernetes cluster kubeconfig save a61716c9-c207-4c23-b789-399a811ef050
Listando todos os pods do Cluster
kubectl get pods --all-namespaces
Utilizando o k9s para visualizar o Cluster
k9s

Na imagem estamos listando todos os containers ativos implantados na criação do cluster. Nos próximos passos iniciaremos a criação do container do order e do payment.

Criando imagens Docker e publicando no Container Registry

Um passo importante no cenário do Kubernetes é construir a imagem Docker dos nossos microsserviços para que possamos realizar a publicação dentro do ambiente do Cluster Kubernetes.

Autenticando o Docker no Container Registry
doctl registry login

Construindo a imagem do microsserviço order no Docker

Entre na pasta do microsserviço order e execute
cd ms-order
docker build -t ms-order .
Crie uma tag para essa imagem
docker tag ms-order registry.digitalocean.com/dp-registry-nyc3/ms-order:latest
Efetuando o push enviando para o Docker
docker push registry.digitalocean.com/dp-registry-nyc3/ms-order:latest

Construindo a imagem do microsserviço payment no Docker

Entre na pasta do microsserviço payment e execute
cd ms-payment
docker build -t ms-payment .
Crie uma tag para essa imagem
docker tag ms-payment registry.digitalocean.com/dp-registry-nyc3/ms-payment:latest
Efetuando o push enviando para o Docker
docker push registry.digitalocean.com/dp-registry-nyc3/ms-payment:latest

Ao final desse procedimento de push nas imagens do order e payment será possível conferir no portal do Container Registry e já estão prontas para utilização no Kubernetes.

Implantando o RabbitMQ no Kubernetes

A plataforma Devprime habilita a conectividade com diversos serviços de Stream com RabbitMQ, Kafka e outros e nesse projeto nós vamos utilizar o helm para implantar o RabbitMQ no cluster. Você pode optar a depender do cenário no seu projeto em utilizar o serviço de Kafka gerenciado oferecido pela Digital Ocean ou outra alternativa para comunicação entre os microsserviços.

Implantando o RabbitMQ utilizando o Helm. Altere o usuário e senha a seu critério.
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update
helm install rabbitmq bitnami/rabbitmq --set auth.username=admin --set auth.password=MQ@passX6DP

O processo de implantação do RabbitMQ demora um certo tempo até concluir e você pode acompanhar pelo K9S. Após a instalação você pode mapear as portas do RabbitMQ no ambiente local para acessar. Antes de realizar o mapemaento é fundamental parar o container local do RabbiMQ para evitar conflitos de portas TCP.

Portas do RabbitMQ

RabbitMQ AMQP port:
kubectl port-forward --namespace default svc/rabbitmq 5672:5672
RabbitMQ Web Management interface:
kubectl port-forward --namespace default svc/rabbitmq 15672:15672

Definindo a configuração inicial do RabbitMQ
Efetue o mapeamento da porta 15672 e acesse o portal administrativo do RabbitMQ pela url http://localhost:15672 para configurar as filas ‘orderevents’ e ‘paymentevents’ no RabbitMQ e relacione com a “exchange” conforme a documentação do RabbitMQ na Devprime com o objetivo de habilitar esse artigo.

Analisando as credenciais do MongoDB e RabbitMQ nos microsserviços ambientes locais

No ambiente local, você pode editar as configurações e credenciais da aplicação no arquivo src/App/appsettings.json, como os dados de acesso ao MongoDB e ao RabbitMQ utilizados no projeto e outros itens disponiveis na documentação de configuração da Devprime.

Para abrir a configuração de cada microsserviço entre na pasta relacionada
ms-order
ms-payment

Abra pelo Visual Studio Code ou outro editor
code src/App/appsettings.json

Visualiuze na chave RabbitMQ e do MongoDB as credenciais do utilizadas no ambiemte local e podem ser modificadas a qualquer momento.

  "DevPrime_Stream": [
    {
      "Alias": "Stream1",
      "Enable": "true",
      "Default": "true",
      "StreamType": "RabbitMQ",
      "HostName": "Localhost",
      "User": "guest",
      "Password": "guest",
      "Port": "5672",
      "Exchange": "devprime",
      "ExchangeType": "direct",
      "Retry": "3",
      "Fallback": "State1",
      "Threads": "30",
      "Buffer": "1",
      "Subscribe": []
    }
  ],

  "DevPrime_State": [
    {
      "enable": "true",
      "alias": "State1",
      "type": "db",
      "dbtype": "mongodb",
      "connection": "mongodb://mongoadmin:LltF8Nx*yo@localhost:27017",
      "timeout": "5",
      "retry": "2",
      "dbname": "ms-order",
      "isssl": "true",
      "durationofbreak": "45"
    }
  ],

Configurando as credenciais do MongoDB e RabbitMQ no Kubernetes

Em nosso contexto, criaremos um arquivo de deployment para cada microsserviço e utilizaremos o DevPrime CLI para construir os arquivos iniciais deployment.yml e service.yml. Para isso, executaremos o comando na pasta de cada microsserviço. Em seguida, realizaremos a configuração com as credenciais que utilizaremos nos microsserviços order e payment dentro do cluster Kubernetes.

Entre na pasta ms-order e execute o comando
dp export kubernetes

Entre na pasta ms-payment e execute o comando
dp export kubernetes

O resultado será similar ao trecho abaixo, com dois arquivos criados contendo as configurações iniciais necessárias para a publicação no Kubernetes. Observe que foram gerados um arquivo deployment.yml e um arquivo service.yml.

 ____             ____       _
|  _ \  _____   _|  _ \ _ __(_)_ __ ___   ___
| | | |/ _ \ \ / / |_) | '__| | '_ ` _ \ / _ \
| |_| |  __/\ V /|  __/| |  | | | | | | |  __/
|____/ \___| \_/ |_|   |_|  |_|_| |_| |_|\___|
  Empower developers. Accelerate productivity
==============================================
Welcome to the DevPrime CLI v8.0.8

Export configurations kubernetes

.devprime/kubernetes/deployment.yml' created
.devprime/kubernetes/service.yml' created

Agora chegou o momento de editar o arquivo “deployment.yml” e localize
o item “image” na pasta do order e na pasta do payment.

Abra a pasta no Visual Studio Code ou outro editor
code .devprime

Arquivo: deployment.yml

apiVersion : apps/v1
kind: Deployment
metadata:
  name: ms-order
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ms-order
  template:
    metadata:
      labels:
        app: ms-order
    spec:
      containers:
        - name: ms-order 
          image: ms-order:latest

Realize o procedimento para cada microsserviço (order / payment) e altere o item image para o path da sua imagem no no Container Registry. A url do Container Registry é a mesma utilizada pelo comando push do docker.

Execute na pasta ms-order
code .devprime/kubernetes/deployment.yml

1
2
3

      containers:
        - name: ms-order 
          image: dpacrcontainer.azurecr.io/ms-order:latest

Execute na pasta ms-payment
code .devprime/kubernetes/deployment.yml

1
2
3

      containers:
        - name: ms-payment 
          image: dpacrcontainer.azurecr.io/ms-payment:latest

Agora chegou um momento de configurar em cada microsserviço as credenciais de produçao do RabbitMQ e do
MongoDB fornecidas pela DigitalOcean e tratadas no inicio do arquivo onde falamos sobre Connection String.

Arquivo:deployment.yaml

         env:
           - name: devprime_stream1
             value: "alias=Stream1|||enable=true|||default=true|||streamtype=RabbitMQ
        |||hostname=rabbitmq.default.svc|||user=admin|||password=guest|||port=5672|||
             exchange=devprime|||exchangetype=direct|||retry=3|||fallback=State1|||
             threads=30|||buffer=1"
           - name: devprime_state1
             value: "enable=true|||alias=State1|||type=db|||dbtype=mongodb|||
             connection=mongodb.default.svc|||timeout=5|||retry=2|||
             dbname=ms-order|||isssl=true|||durationofbreak=45"

No item devprime_stream1 altere o usuário para “admin” e a senha para “MQ@passX6DP”.
no item devprime_state1 altere a connection pela Connection String do MongoDB na DigitalOean.

Abaixo é possível conferir um exemplo após as alterações que devem ser feitas nos arquivos de deployment dos microsserviços (order/payment). Faça a alteração diretamente em cada arquivo para evitar modificar outros parâmetros nessa demonstração, pois as chaves têm pequenas diferenças entre os microsserviços.

Execute na pasta ms-order
code .devprime/kubernetes/deployment.yml

         env:
           - name: devprime_stream1
             value: "alias=Stream1|||enable=true|||default=true|||streamtype=RabbitMQ|||
             hostname=rabbitmq.default.svc|||user=admin|||password=MQ@passX6DP|||
             port=5672|||exchange=devprime|||exchangetype=direct|||retry=3
             |||fallback=State1|||threads=30|||buffer=1"
           - name: devprime_state1
             value: "enable=true|||alias=State1|||type=db|||dbtype=mongodb|||
             connection=mongodb+srv://user:password@
             do-mongodb-nyc1-demo-29a3fecf.mongo.ondigitalocean.com/admin?
             tls=true&authSource=admin&replicaSet=do-mongodb-nyc1-demo|||timeout=5|||
             retry=2|||dbname=ms-order|||isssl=true|||durationofbreak=45"
           - name: Devprime_Custom

Execute na pasta ms-payment
code .devprime/kubernetes/deployment.yml

         env:
           - name: devprime_stream1
             value: "alias=Stream1|||enable=true|||default=true|||streamtype=RabbitMQ|||hostname=rabbitmq.default.svc|||user=admin|||password=MQ@passX6DP|||port=5672|||exchange=devprime|||exchangetype=direct|||retry=3|||fallback=State1|||threads=30|||buffer=1|||subscribe=[queues=orderevents]"
           - name: devprime_state1
             value: "enable=true|||alias=State1|||type=db|||dbtype=mongodb|||
             connection=mongodb+srv://user:password@
             do-mongodb-nyc1-demo-29a3fecf.mongo.ondigitalocean.com/admin?
             tls=true&authSource=admin&replicaSet=do-mongodb-nyc1-demo|||timeout=5|||
             retry=2|||dbname=ms-order|||isssl=true|||durationofbreak=45"
           - name: Devprime_Custom

Executando o deployment dos microsserviços no Kubernetes

Agora chegou o momento mais esperado, onde iremos publicar efetivamente os microsserviços (order e payment) dentro do cluster Kubernetes e para isso utilizaremos os arquivos deployment.yml e service.yml de cada microsserviço.

Entre em cada pasta e execute os comandos abaixo:

Para o microsserviço order
- Navegue até a pasta do Kubernetes do serviço order:
  ms-order/.devprime/kubernetes
- Aplique o deployment e o serviço:
  kubectl apply -f deployment.yml
  kubectl apply -f service.yml
Para o microsserviço ayment
- Navegue até a pasta do Kubernetes do serviço payment:
  ms-payment/.devprime/kubernetes
- Aplique o deployment e o serviço:
  kubectl apply -f deployment.yml
  kubectl apply -f service.yml

Agora que terminamos de efetuar o nosso deployment dos dois microsserviços, podemos visualizar diretamente no cluster pela ferramenta k9s ou utilizando o kubectl.

Efetuando um teste no microsserviço

Abra uma aba do terminal e execute o comando port-forward para mapear o microsserviço order na porta local 8080 e permitir realizar o primeiro teste acessando a plataforma diretamente no cluster.

Execute o comando para o Order
kubectl port-forward --namespace default svc/ms-order 8080:80
Acesse a URL e efetue um POST no microsserviço order para que processe e emita um evento na fila do RabbitMQ e propague para o microsserviço payment
http://localhost:8080

Atribuindo um IP público ao microsserviço order

Abra o arquivo ms-order/.devprime/kubernetes/service.yml com o Visual Studio Code e altere o “ClusterIP” para “LoadBalancer”:

apiVersion: v1
kind: Service
metadata:  
  name: ms-order
spec:
  selector:    
    app: ms-order
  type: LoadBalancer
  ports:  
  - name: http
    port: 80
    targetPort: 80

Excluindo o service ms-order:
kubectl delete svc ms-order

Recriando o service ms-order:
kubectl apply -f service.yml

Agora consulte a atualização até receber um IP público no microsserviço order:
kubectl get svc ms-order -w

NAME       TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
ms-order   LoadBalancer   10.245.38.41   157.x.x.x   80:31256/TCP   2m32s

Visualizando logs no Kuberbernetes

Os microsserviços baseados na plataforma Devprime disponibilizam uma abordagem de observabilidade automática de logs distribuídos que podem ser visualizados pelo kubectl, k9s, stern e indexados em ferramentas como SEQ, Elastic Search e muitas outras para acompanhar o comportamento das aplicações no ambiente produtivo.

Nesse exemplo, utilizaremos a ferramenta stern para visualizar o log de cada deployment:

Abra uma aba para o microsserviço ‘order’ no terminal e execute:
stern ms-order
Abra uma aba para o microsserviço ‘payment’ no terminal e execute:
stern ms-payment
Agora, utilize o mapeamento de porta ou IP público e realize um post no microsserviço ‘order’ para conferir um resultado. No log abaixo, você verá um resumo do ‘order’ como exemplo.

[INF][ms-order][Web]["http://*:80"][Host]["Production"][Parameters]["Environment"][RID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8][TID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8]
[INF][ms-order][Stream][Type "RabbitMQ"][Alias "Stream1"]["Enable"][RID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8][TID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8]
[INF][ms-order][Web]["HTTP"][Order][POST /v1/order][Origin "http://localhost/swagger/index.html"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Application][OrderService][Add][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Domain][Order][Add][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Domain][Order][ProcessEvent]["CreateOrder"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Application][EventHandler]["CreateOrderEventHandler"][Event]["CreateOrder"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][State][Type "MongoDB"][Alias "State1"][Initialize][OrderRepository][Add][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][State][Type "MongoDB"][Alias "State1"][Complete][OrderRepository][Add][Duration 1192.1472ms][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Domain][Order][ProcessEvent]["OrderCreated"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Application][EventHandler]["OrderCreatedEventHandler"][Event]["OrderCreated"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Stream][Type "RabbitMQ"][Alias "Stream1"][Out][Event]["OrderCreated"]["Delivered"]["orderevents"]
["{\""Payload\":{\"ID\":\"ca9983\",\"CustomerName\":\"Ramon Duraes\",\"CustomerTaxID\":\"AC875512\",\"Total\":1200}}"]

Considerações finais

Durante este artigo, demonstramos a publicação de dois microsserviços (order e payment) desenvolvidos utilizando a tecnologia da plataforma Devprime no cluster Kubernetes (DOKS) da DigitalOcean, em conjunto com os serviços de Container Registry e MongoDB gerenciados e com o RabbitMQ que implantamos no cluster utilizando o Helm. Você acompanhou também como acessar o serviço utilizando um IP interno e um IP Externo e visualizar os logs.

Em um ambiente produtivo, é fundamental adicionar um nginx ingress, um dominio de internet e Let’s Encrypt para gerar um certificado SSL, utilizar um serviço de DevOps para automatizar a publicação, cofre digital para credenciais, proteção de acesso com um API Gateway, provedor de identidade e Web Application Firewall.

Para saber mais

Implantando um microsserviço Devprime em um Droplet DigitalOcean