Como Criar e Implantar

Microsserviços com Python

Downloaded on: 26 August 2024

 Ship and manage your
web projects faster
Deploy your projects on Google Cloud Platform's top tier
infrastructure. You'll get 25+ data centers to choose
from, 24/7/365 expert support, and advanced security
with DDoS protection.

Try for free

No desenvolvimento moderno de software, os microsserviços surgiram como uma arquitetura

essencial, permitindo o dimensionamento, a flexibilidade e o gerenciamento eficiente de
sistemas complexos.

Microsserviços são pequenos aplicativos independentes que executam tarefas específicas,

permitindo uma implantação flexível e escalonamento. Essa abordagem modular para o
design de software reduz o acoplamento entre componentes, aumentando a flexibilidade e a
capacidade de gerenciamento ao longo do desenvolvimento.

O artigo apresenta uma visão geral dos microsserviços, sua funcionalidade e sua criação
usando Python. Ele também demonstra a implantação de seus microsserviços na Kinsta
usando um Dockerfile.

O que são microsserviços?

Os microsserviços são serviços independentes e autônomos dentro de um aplicativo, cada
um atendendo a necessidades comerciais específicas. Eles se comunicam por meio de APIs
leves ou corretores de mensagens, formando um sistema abrangente.
Ao contrário dos sistemas monolíticos que são dimensionados inteiramente com base na
demanda, os microsserviços permitem o dimensionamento de componentes individuais de
alto tráfego. Essa arquitetura facilita o gerenciamento de falhas e as atualizações de
recursos, contrariando as limitações monolíticas.

Há vários benefícios no uso de microsserviços, tais como:

Flexibilidade e dimensionamento – O desacoplamento de serviços individuais

permite que você aumente o número de nodes que executam uma instância de um
determinado serviço com alto tráfego.
Modularidade do código – Cada serviço pode usar uma pilha de tecnologia discreta, o
que significa que você pode escolher as melhores ferramentas de desenvolvimento
para cada um deles.

No entanto, algumas dificuldades acompanham as arquiteturas de microsserviços:

Monitoramento de vários serviços – O monitoramento de serviços individuais em um

sistema torna-se um desafio à medida que as instâncias de um determinado serviço
são implantadas e distribuídas em vários nodes. Essa dificuldade é especialmente
aparente durante falhas de rede ou outros problemas do sistema.
Custo – O desenvolvimento de aplicativos de microsserviços pode ser
significativamente mais caro do que a criação de sistemas monolíticos devido aos
custos associados ao gerenciamento de vários serviços. Cada serviço requer sua
própria infraestrutura e seus próprios recursos, o que pode se tornar dispendioso,
principalmente quando você estiver ampliando o sistema.

Como projetar um microsserviço usando Python

Agora que você conhece os benefícios de usar uma arquitetura de microsserviço, é hora de
criar uma com Python.

Para este exemplo, suponha que você queira criar um aplicativo web de eCommerce. O site
tem vários componentes, incluindo o catálogo de produtos, uma lista de pedidos e um
sistema de processamento de pagamentos e registros, cada um dos quais você precisa
implementar como um serviço independente. Além disso, você precisa estabelecer um
método de comunicação serviço a serviço para transferir dados entre esses serviços, como
HTTP, de forma eficiente.

Vamos criar um microsserviço usando Python para gerenciar um catálogo de produtos. O

microsserviço buscará dados de produtos de uma fonte especificada e retornará os dados no
formato JSON.

Pré-requisitos

Para seguir este tutorial, certifique-se de que você tenha:

Familiaridade com o Flask

Python, Postman Client e Docker Desktop instalados em seu computador

1. Crie seu projeto

1. Para começar, crie uma pasta para o seu projeto chamado flask-microservice e o
diretório atual no diretório do projeto.
2. Em seguida, execute python3 --version para confirmar se o Python está instalado
corretamente em seu computador.
3. Instale o site virtualenv para criar um ambiente de desenvolvimento isolado para o
microsserviço Flask executando o comando abaixo:

pip3 install virtualenv

4. Crie um ambiente virtual executando o seguinte:

 virtualenv venv

5. Por fim, ative o ambiente virtual usando um dos seguintes comandos, de acordo com o
sistema operacional do seu computador:

# Windows:
.\venv\Scripts\activate
# Unix or macOS:
source venv/bin/activate

2. Configure um servidor Flask

No diretório raiz, crie um arquivo [Link] e adicione essas dependências.

flask
requests

Execute o arquivo pip3 command on your terminal to install the

dependencies.
 pip install -r [Link]

Em seguida, crie uma nova pasta no diretório raiz e nomeie-a como services. Dentro dessa
pasta, crie um novo arquivo, [Link], e adicione o código abaixo para configurar um
servidor Flask.

import requests
import os
from flask import Flask, jsonify
app = Flask(__name__)
port = int([Link]('PORT', 5000))

@[Link]("/")
def home():
return "Hello, this is a Flask Microservice"
if __name__ == "__main__":
[Link](debug=True, host="[Link]", port=port)

No código acima, um servidor Flask básico é configurado. Ele inicializa um aplicativo Flask,
define uma única rota para a URL raiz ("/") e, quando acessado, exibe a mensagem
"Hello, this is a Flask Microservice". O servidor é executado em uma porta
especifica, obtida de uma variável de ambiente ou tem como padrão a porta 5000, e é
iniciado no modo de depuração, deixando pronto para lidar com as solicitações recebidas.

3. Defina os endpoints da API

Com o servidor configurado, crie um endpoint de API para um microsserviço que busca
dados de produtos em uma API disponível publicamente. Adicione este código ao arquivo
[Link]:

BASE_URL = "[Link]
@[Link]('/products', methods=['GET'])
def get_products():
response = [Link](f"{BASE_URL}/products")
if response.status_code != 200:
return jsonify({'error': [Link]()['message']}), [Link]
products = []
for product in [Link]()['products']:
product_data = {
'id': product['id'],
'title': product['title'],
'brand': product['brand'],
'price': product['price'],
'description': product['description']
}
[Link](product_data)
return jsonify({'data': products}), 200 if products else 204

O código acima cria um endpoint /products no servidor Flask. Quando acessado via uma
requisição GET, ele busca dados de produtos de uma API dummy. Se bem-sucedido,
processa os dados obtidos, extrai detalhes do produto e retorna as informações em formato
JSON. Em caso de erros ou ausência de dados disponíveis, responde com uma mensagem
de erro apropriada e código de status.

4. Teste o microsserviço

Neste ponto, você configurou com êxito um microsserviço simples. Para iniciar o serviço,
ative o servidor de desenvolvimento, que começará a ser executado em
[Link]
 flask --app services/products run

Em seguida, você pode fazer uma solicitação GET para o endpoint /products usando o
cliente Postman. Você deverá ver uma resposta semelhante à captura de tela abaixo.

— Testando a solicitação da API HTTP GET no Postman.

Como implementar a autenticação e a autorização em um
microsserviço Python
Ao criar microsserviços, é importante implementar medidas de segurança robustas, como
autenticação e autorização. A segurança do microsserviço garante que somente usuários
autorizados possam acessar e usar o serviço, protegendo dados confidenciais e evitando
ataques mal-intencionados.

Um método eficaz para implementar autenticação e autorização seguras em microsserviços

são os JWTs (JSON Web Tokens).

O JWT é um padrão aberto amplamente usado que oferece uma maneira segura e eficiente
de transmitir informações de autenticação entre clientes e servidores. Eles são tokens
compactos, criptografados e assinados digitalmente que você transmite junto com as
solicitações HTTP. Quando você inclui um JWT em cada solicitação, o servidor pode verificar
rapidamente a identidade e as permissões de um usuário.

Para implementar a autenticação JWT no microsserviço, faça o seguinte:

1. Adicione o pacote pyjwt do Python ao seu arquivo [Link] e reinstale as

dependências usando pip install -r [Link].
2. Como o serviço não tem um banco de dados dedicado, crie um arquivo [Link] no
diretório raiz do seu projeto para armazenar uma lista de usuários autorizados. Cole o
código abaixo no arquivo:

[
{
"id": 1,
"username": "admin",
"password": "admin"
 }
]

Info

Você pode configurar facilmente seu banco de dados preferido (

PostgreSQL, MariaDB, Redis e MySQL) para seus microsserviços
com nosso serviço de hospedagem de banco de dados.

3. Em seguida, em seu arquivo services/[Link], substitua as instruções de

importação pelo seguinte:

import requests
from flask import Flask, jsonify, request, make_response
import jwt
from functools import wraps
import json
import os
from [Link] import DecodeError
 Você está importando esses módulos para lidar com solicitações HTTP, criar um
aplicativo Flask, gerenciar dados JSON, implementar autenticação baseada em JWT e
lidar com exceções, permitindo uma ampla gama de recursos no servidor Flask.

4. Adicione o seguinte código abaixo da criação da instância do aplicativo Flask para

gerar uma chave secreta que será usada para assinar os tokens JWT.

[Link]['SECRET_KEY'] = [Link](24)

5. Para verificar os JWTs, crie uma função de decorador e adicione o seguinte código
acima das rotas de API no código do servidor Flask. Essa função de decorador
autenticará e validará os usuários antes que eles acessem as rotas protegidas.

def token_required(f):
@wraps(f)
def decorated(*args, **kwargs):
token = [Link]('token')
if not token:
return jsonify({'error': 'Authorization token is missing'}
try:
data = [Link](token, [Link]['SECRET_KEY'], algorit
current_user_id = data['user_id']
except DecodeError:
return jsonify({'error': 'Authorization token is invalid'}
return f(current_user_id, *args, **kwargs)
return decorated
 Essa função de decorador verifica as solicitações HTTP de entrada em busca de um
token de autorização JWT, que deve estar nos cabeçalhos de solicitação ou nos
cookies. Se o token estiver faltando ou for inválido, o decorador enviará uma
mensagem unauthorized status code como resposta.

Por outro lado, se um token válido estiver presente, o decorador extrai a ID do usuário
após decodificá-la. Esse processo protege os endpoints de API protegidos, concedendo
acesso somente a usuários autorizados.

6. Defina um endpoint de API para autenticação de usuário usando o código abaixo.

with open('[Link]', 'r') as f:

users = [Link](f)
@[Link]('/auth', methods=['POST'])
def authenticate_user():
if [Link]['Content-Type'] != 'application/json':
return jsonify({'error': 'Unsupported Media Type'}), 415
username = [Link]('username')
password = [Link]('password')
for user in users:
if user['username'] == username and user['password'] == passwo
token = [Link]({'user_id': user['id']}, [Link]['SE
response = make_response(jsonify({'message': 'Authenticati
response.set_cookie('token', token)
return response, 200
return jsonify({'error': 'Invalid username or password'}), 401

Para autenticar e autorizar os usuários, o endpoint da API /auth verifica as

credenciais no payload JSON da solicitação POST em relação à lista de usuários
permitidos. Se as credenciais forem válidas, ele gera um token JWT usando o ID do
usuário e a chave secreta do aplicativo e define o token como um cookie na resposta.
Os usuários agora podem usar esse token para fazer solicitações de API
 subsequentes.

Depois de criar o endpoint /auth, use o Postman para enviar uma solicitação HTTP
POST para [Link] No corpo da solicitação, inclua as
credenciais do usuário administrador simulado que você criou.

— Solicitação do Postman mostrando o corpo da solicitação.

Se a solicitação for bem-sucedida, a API gerará um token JWT, o definirá nos cookies
do Postman e enviará uma resposta de sucesso autenticada.

7. Por fim, atualize o endpoint da API GET para verificar o token JWT usando o código
abaixo:

@[Link]('/products', methods=['GET'])
@token_required
def get_products(current_user_id):
 headers = {'Authorization': f'Bearer {[Link]("token")
response = [Link](f"{BASE_URL}/products", headers=headers)
if response.status_code != 200:
return jsonify({'error': [Link]()['message']}), respons
products = []
for product in [Link]()['products']:
product_data = {
'id': product['id'],
'title': product['title'],
'brand': product['brand'],
'price': product['price'],
'description': product['description']
}
[Link](product_data)
return jsonify({'data': products}), 200 if products else 204

Como colocar microsserviços Python em contêineres

com o Docker
O Docker é uma plataforma que empacota aplicativos e suas dependências em um ambiente
de desenvolvimento isolado. O empacotamento de microsserviços em contêineres simplifica
os processos de implantação e gerenciamento nos servidores, pois cada serviço é executado
de forma independente em seu contêiner.

Para contêinerizar o microsserviço, você deve criar uma imagem do Docker a partir de um
Dockerfile que especifique as dependências necessárias para executar o aplicativo em um
contêiner. Crie um Dockerfile no diretório raiz do seu projeto e adicione estas instruções:
 FROM python:3.9-alpine
WORKDIR /app
COPY [Link] ./
RUN pip install -r [Link]
COPY . .
EXPOSE 5000
CMD ["python", "./services/[Link]"]

Antes de criar a imagem, você deve revisar estes comandos:

FROM – Instrui o Docker sobre qual imagem de base você deve usar. Uma imagem de
base é uma instância pré-criada que contém o software e as dependências para
executar o aplicativo Flask em um contêiner.
WORKDIR – Define o diretório especificado dentro do contêiner como o diretório de
trabalho.
COPY [Link] ./ – Copia as dependências do arquivo [Link]
para o arquivo [Link] do contêiner.
RUN – Executa o comando especifico para instalar as dependências que a imagem
requer.
COPY . . – Copia todos os arquivos do diretório raiz do projeto para o diretório de
trabalho dentro do contêiner.
EXPOSE – Especifica a porta em que o contêiner escutará as solicitações. No entanto, o
Docker não publica a porta na máquina host.
CMD – Especifica o comando padrão a ser executado quando o contêiner for iniciado.

Em seguida, adicione um arquivo .dockerignore no diretório raiz do seu projeto para

especificar os arquivos que a imagem do Docker deve excluir. Limitar o conteúdo da imagem
reduzirá seu tamanho final e o tempo de build associado.
 /venv
/services/__pycache__/
.gitignore

Agora, execute o comando abaixo para criar a imagem do Docker:

docker build -t flask-microservice .

Por fim, depois que a imagem for criada, você poderá executar o microsserviço em um
contêiner do Docker usando o seguinte comando:

docker run -p 5000:5000 flask-microservice

Este comando iniciará um contêiner Docker executando o microsserviço e mapeará a porta

5000 do contêiner para a porta 5000 na máquina host, permitindo que você faça requisições
HTTP a partir do seu navegador web ou Postman usando a URL
[Link]

Implante microsserviços Python com a Kinsta

A Kinsta oferece soluções de hospedagem gerenciada para aplicativos web e bancos de
dados – você pode implantar e gerenciar perfeitamente seus microsserviços Python e APIs
de backend em um ambiente de produção.
Siga estas etapas para configurar seu microsserviço Flask para implantação com o MyKinsta:

1. Primeiro, crie um novo Procfile no diretório raiz e adicione o código abaixo. Ele
especifica o comando para executar o microsserviço do Flask no servidor HTTP
Gunicorn WSGI da Kinsta para aplicativos Python.

web: gunicorn [Link]

2. Em seu arquivo [Link], adicione a dependência do Gunicorn:

gunicorn==20.1.*

3. Em seguida, crie um novo arquivo services/[Link] e adicione o código abaixo.

from [Link] import app as application

if __name__ == "__main__":
[Link]()

4. Crie um arquivo .gitignore na pasta raiz do projeto e adicione o seguinte:

 services/__pycache__
venv

5. Por fim, crie um novo repositório no GitHub e faça push dos arquivos do projeto.

Quando seu repositório estiver pronto, siga estas etapas para implantar o microsserviço do
Flask na Kinsta:

1. Faça login ou crie uma conta para visualizar seu painel MyKinsta.
2. Autorize a Kinsta no seu provedor Git (Bitbucket, GitHub ou GitLab).
3. Clique em Aplicativos na barra lateral esquerda e, em seguida, clique em Adicionar
aplicativo.
4. No painel, clique em Adicionar serviço e selecione Aplicativo.
5. Escolha o repositório e a branch que você deseja usar para a implantação.
6. Atribua um nome exclusivo ao seu aplicativo e escolha um local de centro de dados.
7. Para configurar o ambiente de build, selecione a opção para usar um Dockerfile para
criar a imagem do contêiner.
8. Forneça o caminho para o seu Dockerfile e o contexto.
9. Por fim, revise outras informações e clique em Criar aplicativo.

Teste o microsserviço

Quando o processo de implantação for bem-sucedido, clique na URL fornecida para testar o
microsserviço fazendo solicitações HTTP no Postman. Faça uma solicitação GET para o
endpoint raiz.
 — Faça uma solicitação HTTP API GET para o endpoint product do microsserviço.

Para autenticar e gerar um token JWT, envie uma solicitação POST para o endpoint da API
/auth, passando as credenciais de administrador no corpo da solicitação.
 — Solicitação de API HTTP POST para o endpoint do microsserviço auth.

Por fim, após a autenticação bem-sucedida, faça uma solicitação GET para o endpoint
/products para buscar dados.
 — Solicitação da API HTTP GET para um endpoint do microsserviço products.

Resumo
À medida que os aplicativos aumentam em tamanho e complexidade, é fundamental adotar
padrões de arquitetura que permitam que os sistemas de software sejam dimensionados sem
sobrecarregar os recursos disponíveis.

A arquitetura de microsserviços oferece escalabilidade, flexibilidade de desenvolvimento e

facilidade de manutenção, tornando mais fácil para você gerenciar aplicativos complexos.

A Kinsta simplifica o processo de hospedagem de seus microsserviços. Ele permite que você
use sem esforço o banco de dados de sua preferência e hospede de forma conveniente o
aplicativo e o banco de dados por meio de um painel unificado.