Sua tarefa é pequena ou você pode dividi-la em tarefas menores. E uma pequena tarefa é perfeita para um microsserviço.

O design de software é uma fase essencial no desenvolvimento de software. A abordagem de design pode afetar todo o projeto e como você lida com diferentes requisitos.

Os desenvolvedores costumam usar uma arquitetura monolítica, agrupando todos os componentes de software em um único módulo. No entanto, essa abordagem pode ser ineficiente, principalmente para aplicações maiores.

Os microsserviços visam resolver essas limitações. Um microsserviço é um aplicativo pequeno e modular que executa funções específicas. Ao contrário dos aplicativos monolíticos, os microsserviços permitem implantação e dimensionamento independentes. Como resultado, eles são mais flexíveis e fáceis de manter.

A arquitetura de microsserviços

A arquitetura de microsserviço é uma abordagem de design de software que divide um grande aplicativo em serviços independentes, com cada serviço projetado para atender a um requisito de negócios específico.

Esses serviços são executados em recursos dedicados, incluindo instâncias de banco de dados separadas e poder de computação. Ao contrário dos sistemas monolíticos, os aplicativos de microsserviços são fracamente acoplados, permitindo maior flexibilidade.

Em um sistema distribuído, os nós do servidor implantam e executam aplicativos de microsserviços separadamente processos — comunicando-se uns com os outros usando protocolos de comunicação como HTTP ou por meio de corretores de mensagens como RabbitMQ.

Essencialmente, essa abordagem arquitetônica permite que os serviços mantenham sua independência uns dos outros enquanto operam efetivamente dentro do sistema de software.

Neste tutorial, orientaremos você na implementação de um microsserviço de usuário simples que gerencia os dados do usuário usando Flask e PostgreSQL

Configurar um banco de dados PostgreSQL

Para começar, instale o PostgreSQL. Se você não tem o PostgreSQL instalado, você pode descobrir como instalar o PostgreSQL no Windows ou como instalar o PostgreSQL no macOS.

Alternativamente, você pode configurar um banco de dados PostgreSQL remoto instância.

Este guia usará o nível gratuito do Render para configurar um banco de dados PostgreSQL. Siga estes para ativar uma instância de banco de dados PostgreSQL no Render:

  1. Dirija-se a Site do Render, cadastre-se em uma conta e faça login no seu painel página.
  2. Na página do painel, na lista de serviços exibida, selecione o serviço PostgreSQL.
  3. Na página de configurações do banco de dados, preencha os detalhes necessários e certifique-se de selecionar o nível gratuitoe finalmente clique Criar banco de dados.

Você pode encontrar o código deste projeto neste Repositório GitHub.

Criar um Microsserviço Flask

  1. No seu terminal, crie um novo diretório e mude para ele:
    mkdir flask-microservice
    cd flask-microservice
  2. Em seguida, instale virtualenv, para criar um ambiente de desenvolvimento virtual isolado.
    pip instalar virtualenv
  3. Crie um ambiente virtual em seu projeto:
    virtualenv venv
  4. Por fim, ative o ambiente virtual.
    # Janelas: 
    .\venv\Scripts\ativar
    # Unix ou MacOS: 
    fonte venv/bin/ativar

Instale os pacotes necessários

  1. Crie um novo requisitos.txt arquivo no diretório raiz e adicione estes pacotes:
    frasco
    psycopg2-binary
    sqlalchemy
  2. Em seguida, instale os pacotes.
    pip install -r requisitos.txt

Criar um Servidor Flask

No diretório raiz, crie um novo arquivo: service.py, e o seguinte código:

  1. Faça as seguintes importações:
    de frasco importar Frasco, solicitação, jsonify
    de sqlalchemy importar create_engine, Coluna, Inteiro, String
    de sqlalchemy.orm importar criador de sessões
    de sqlalchemy.ext.declarative importar base_declarativa
    importar psicopg2
  2. Crie a instância do Flask e configure a conexão com o banco de dados.
    app = Frasco (__name__)
    motor = create_engine("postgresql+psycopg2://flask_service_fe0v_user: 4785MhjfkdjfhjfjyUx67O2Nuzjchb2MQIP@dpg-chffjfjdkgfk54d6mb7860-a.oregon-postgres.render.com/flask_service_fe0v")
    Copie o URL do banco de dados externo na página de configurações do banco de dados do Render. vamos usar o SQLAlchemy create_engine método e Psycopg2 para configurar a conexão do banco de dados. Certifique-se de atualizar e substituir o URL do banco de dados no código acima pelo URL de sua própria instância do PostgreSQL que corresponda ao formato especificado acima. Se o formato da URL estiver incorreto, o código gerará um erro.
  3. Crie um modelo SQLAlchemy para o banco de dados.
    Base = base_declarativa()
    aulaDo utilizador(Base):
     __tablename__ = 'Usuários'
     id = Coluna (Inteiro, primary_key=Verdadeiro)
     nome = Coluna (String(50))
    Base.metadata.create_all (mecanismo)
    imprimir("Tabela 'usuários' criada com sucesso.")
    Sessão = criador de sessão (mecanismo)
    O código define um modelo de dados para a tabela dos usuários. Após definir o modelo, ele cria a tabela usando o SQLAlchemy create_all método que pega o banco de dados objeto do mecanismo de conexão como parâmetro. Finalmente, ele cria uma instância do criador de sessões usando o mesmo objeto de mecanismo para permitir interações com o banco de dados.
  4. Por fim, defina as rotas de API para o microsserviço.
    @app.route("/api/user", method=["POST"])
    defcriar_usuário():
     dados = request.get_json()
     nome = dados["nome"]
    tentar:
     sessão = Sessão()
     new_user = Usuário (nome=nome)
     sessão.add (novo_usuário)
     sessão.commit()
    retornar {"eu ia": new_user.id, "nome": novo usuário, "mensagem": f"Usuário {nome} criada."}, 201
    exceto Exceção como e:
     imprimir(f"O erro '{e}' ocorreu.")
    retornar {"erro": "Ocorreu um erro ao criar o usuário."}, 500
    @app.route("/api/user", method=["GET"])
    defget_all_users():
    tentar:
     sessão = Sessão()
     usuários = sessão.consulta (Usuário).all()
    se Usuários:
     resultado = []
    para do utilizador em Usuários:
     result.append({"eu ia": ID do usuário, "nome": nome de usuário})
    retornar jsonify (resultado)
    outro:
    retornar jsonify({"erro": f"Usuários não encontrados."}), 404
    exceto Exceção como e:
     imprimir(f"O erro '{e}' ocorreu.")
    retornar {"erro": "Ocorreu um erro ao obter todos os usuários."}, 500
    se __nome__ == "__principal__":
     app.run (depurar=Verdadeiro, hospedeiro="0.0.0.0")

Teste o microsserviço

O código acima demonstra um microsserviço simples de dados do usuário que adiciona e busca dados de um banco de dados PostgreSQL. Idealmente, os microsserviços espelham o Arquitetura da API REST uma vez que permite uma abordagem flexível para a criação de serviços da Web, essa arquitetura se adapta bem ao padrão de design de microsserviços.

No entanto, é importante observar que os microsserviços também podem usar outros tipos de abordagens de design e protocolos de comunicação, dependendo das necessidades específicas do sistema.

Para testar o serviço, ative o servidor de desenvolvimento e vá até o Postman para fazer solicitações HTTP aos terminais definidos.

flask --execução do serviço de aplicativo

No Postman, faça uma solicitação POST para adicionar dados do usuário.

Containerização de microsserviços com Docker

O Docker agrupa aplicativos e suas dependências em contêineres. Essa abordagem simplifica o desenvolvimento, a implantação e o gerenciamento de microsserviços em um ambiente de produção uma vez que cada serviço pode operar de forma independente e se comunicar com outros serviços usando a comunicação configurada protocolo.

Antes de começar, você precisa primeiro instalar o Docker seguindo as etapas no site Docker. Em seguida, crie uma imagem do Docker a partir de um Dockerfile que contém as instruções necessárias para configurar as dependências necessárias para executar o aplicativo em um contêiner.

  1. Crie um Dockerfile no diretório raiz da pasta do seu projeto e adicione estas instruções:
    DE Pitão:3.9-alpino
    WORKDIR /app
    CÓPIA DE requisitos.txt ./
    CORRER pip install -r requisitos.txt
    CÓPIA DE. .
    EXPOR5000
    CMD ["Pitão", "./serviço.py"]
  2. Execute o comando abaixo para criar a imagem do Docker.
     docker build -t flask-microservice .
  3. Por fim, execute o contêiner do Docker.
    docker run -p 5000:5000 flask-microservice

Isso iniciará um contêiner do Docker executando o microsserviço Flask e exporá a porta 5000 no contêiner para porta 8000 na máquina host, permitindo que você faça solicitações HTTP de seu navegador da Web ou Postman usando o URL http://localhost: 5000.

Adotando a arquitetura de microsserviços

A arquitetura de microsserviços tornou-se uma abordagem popular para o desenvolvimento de aplicativos de software robustos e escaláveis. Ao dividir o aplicativo em serviços pequenos e implementáveis ​​de forma independente, a arquitetura de microsserviços facilita a manutenção e o dimensionamento do sistema.

Embora essa arquitetura tenha benefícios potenciais, ela não é adequada para todos os casos de uso. Em qualquer caso, os requisitos de negócios específicos do projeto devem influenciar principalmente a abordagem de design adotada.