microservices

Table of Contents

Agora vamos para o próximo nível da nossa aplicação. Como já temos a API pré-configurada com as filas e as tabelas do banco criados, começaremos a criar os microservices para consumi-las. A arquitetura do serviço será bem semelhante ao que criamos na API, contendo requirements, dockerfile, docker-compose, pasta de config e mais algumas coisas.

Na pasta raiz da aplicação MS-Application, vamos criar os seguintes arquivos:

MS-application
└───MS1
    │   docker-compose-microservice1.yml
    │   Dockerfile
    │   main.py
    │   requirements.txt
    │
    ├───config
    │       database_connection.py
    │       rabbitmq_connection.py
    │       __init__.py

Config

Na pasta config , os arquivos database_connection.py e rabbitmq_connection.py são exatamente as mesmas configurações dos arquivos contido na API, então apenas vamos copiar aos arquivos da API.

Requeriments

No arquivo requeriments.txt ficarão todas as instalações de bibliotecas e framework que serão utilizados na aplicação do microservices. As bibliotecas devem ficar separadas por linha, visto que usaremos um comando para uma instalação recursiva.

requirements.txt
   psycopg2-binary
   argon2-cffi
   flask
   pika

Comando para instalação:

pip install -r requeriments.txt

Docker-Compose

No arquivo docker-compose-microservice1.yml, configuraremos a inicialização da imagem do serviço. Será feito o Build da imagem que criaremos posteriormente, apontado a Network que criamos juntamente aos serviços logo no início do projeto.

version: "3.7"
services:
  microservice1:
    build: .
    networks:
      - internal-network

networks:
    internal-network:
        external: true

Dockerfile

No arquivo Dockerfile iremos configurar a imagem de nosso primeiro microservices, contendo as variáveis de ambiente adequadas para o serviço. Diferente da imagem do python que usamos na API, no microservice precisaremos instalar a imagem completa do python, sendo ela: python:3.8.

FROM python:3.8
COPY . /app/
ENV HOST='10.0.0.25'
ENV HOST_DATABASE='10.5.0.11'
WORKDIR /app
RUN pip install --upgrade pip
RUN pip install -r requirements.txt
CMD python main.py

Main.py

O arquivo main.py será responsável por interceptar as mensagens enviadas para a fila de usuário.

Primeiramente, devemos importar os arquivos de conexão com o postgres e rabbit. Após isso, criaremos a classe Main(), onde no método __init__, chamaremos as conexões com os servidores.

from config.database_connection import ConnectionDatabase
from config.rabbitmq_connection import ConnectionRabbitMq
from rabbitmq_controller.rabbit_worker import RabbitWorker

class Main():

    def __init__(self):
        self.PSQL = ConnectionDatabase()
        self.RMQ = ConnectionRabbitMq()
        self.RMQ_WORKER = RabbitWorker()

Feito isso, criaremos um método chamado consume_queue, que consumirá a fila que desejamos. Nesse caso será user, e posteriormente o consumo disparará uma função para o processamento do dado recebido da fila. Nesse momento não iremos criar a função de processamento, porem iremos apenas nomeá-la no lugar correto.

Com o comando basic_consume consumiremos a fila user, no on_message_callback será disparado a função para o processamento da informação recebida na fila.

Com o comando start_consuming, é processado o evento de I/O até que todos as mensagens sejam processadas.

    def consume_queue(self):
        self.RMQ.channel.basic_qos(prefetch_count=1)
        self.RMQ.channel.basic_consume(queue='user', on_message_callback=self.RMQ_WORKER.callback)

        print('     [⇄] Waiting for messages. To exit press CTRL+C')
        self.RMQ.channel.start_consuming()

Finalizaremos com a chamada do método consume_queue para inicializar o serviço.

if __name__ == '__main__':

    MA = Main()
    MA.consume_queue()

Resumo

Nesse Step criamos nosso primeiro microservices para o processamento dos dados recebidos através da fila de usuário. Copiamos os arquivos de conexão database_connection.py e rabbitmq_connection.py da API, visto que é a mesma conexão que precisaremos fazer nos microservices. Também criamos o arquivo main.py que será o responsável por inicializar o serviço e disparar o método consume_queue, que como o próprio nome diz, irá consumir a fila de usuários.