Droplet

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.

1. Entre na nova pasta ms-order e abra pelo Visual Studio Code
   code src\App\appsettings.json
2. Localize a chave “DevPrime_Stream” e na opção “Enable” coloque “false”.
3. 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

    "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.

1. 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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

[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

2. Reinicie o daemon:
   sudo systemctl daemon-reload

3. Habilite o novo serviço devprime:
   sudo systemctl enable devprime

4. Iniciando o serviço. Nesse momento, você já pode acessar pela Web novamente:
   sudo systemctl start devprime

5. Verificando o status:
   sudo systemctl status devprime

6. Opcional para reiniciar o serviço quando necessário:
   sudo systemctl restart devprime

7. Acompanhando os logs do microsserviço:
   sudo journalctl -f -u devprime

8. 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.

1. 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

2. Reinicie o microserviço.
   sudo systemctl restart devprime

3. Instalando o Nginx no Droplet.
   sudo apt update && sudo apt install nginx

4. Verificando o status.
   sudo systemctl status nginx

5. Tornando o Nginx um Service.
   sudo systemctl enable nginx

6. Instalando Certbot e o plugin Nginx.
   sudo apt update && sudo apt install certbot
sudo apt install python3-certbot-nginx

7. 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

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   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; } }

9. Crie um link simbólico.
   sudo ln -s /etc/nginx/sites-available/do.devprime.io /etc/nginx/sites-enabled/

10. Valide a configuração do Nginx.
    sudo nginx -t

11. Reinicialize o Nginx.
    sudo systemctl restart nginx

12. 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>

12. 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

13. Listando o crontab ativos.

    1 2	crontab -l sudo ls /etc/cron.d/

14. 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)