microservices

Table of Contents

Com a finalização do MS1, vamos criar o segundo microservice que será o responsável por criar a manipular as orders relacionada a um usuário. A arquitetura de pastas será semelhante ao microservice 1, 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
└───MS2
    │   docker-compose-microservice2.yml
    │   Dockerfile
    │   main.py
    │   requirements.txt
    │
    ├───config
    │       database_connection.py
    │       rabbitmq_connection.py
    │       __init__.py

Config

Como no primeiro microsserviço, os arquivos de conexão serão exatamente iguais, então apenas copiaremos e colararemos a pasta config para o MS2. Nela, deve conter database_connection.py e rabbitmq_connection.py para a conexão com os serviços.

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.

psycopg2-binary
flask
pika

Comando para instalação:

pip install -r requeriments.txt

Docker-Compose

No arquivo docker-compose-microservice2.yml, iremos configurar 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:

  microservice2:

    build: .

    networks:

      - internal-network



networks:

    internal-network:

        external: true

Dockerfile

No arquivo Dockerfile configuraremos a imagem do microservice, 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 orders.

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á order, e posterior o consumo, irá disparar uma função para o processamento do dado recebido da fila. Nesse momento não iremos criar a função de processamento, porém iremos apenas nomeá-la no lugar correto.

Com o comando basic_consume consumiremos a fila order, e 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='order', 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 o microservice 2 para o processamento dos dados recebidos através da fila de order. Copiamos os arquivos de conexão database_connection.py e rabbitmq_connection.py do Microservice 1, visto que é a mesma conexão que precisaremos fazer. 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, consumirá a fila de usuários.