Guia para desenvolver uma API em Python utilizando Flask, Docker, Gunicorn e AWS

Aprenda a criar uma API em Python e containerizá-la com Docker para rodar em uma instância EC2 da AWS

Victor Bona

7 min

Um guia para desenvolver uma simples API em Python utilizando flask, docker, gunicorn e AWS.

Introdução

Em muitos momentos ao desenvolver um software ou uma aplicação, nos vemos em uma situação que precisamos implementar um serviço destacado da estrutura principal, ou até mesmo criarmos uma solução para resolvermos um problema em especial seu ou de outras pessoas. Para esta tarefa, pode ser interessante desenvolver uma API, capaz de ser utilizado em qualquer sistema com acesso a internet. Ao final do artigo, você terá aprendido de forma simples e rápida como criar uma API em python, conteinerizar ela utilizando docker, subir para uma instância EC2 da AWS e rodar a API utilizando um servidor HTTP.

Defina sua arquitetura

Parte importante ao desenvolver uma API, é definir a melhor arquitetura para seu propósito, no nosso caso, estaremos utilizando a seguinte: Programaremos a API em Python, utilizando o micro-framework Flask, Gunicorn para o servidor HTTP, docker para a conteinerização e uma instância EC2 da AWS como nossa maquina virtual que irá rodar a API. Cada elemento da arquitetura será melhor explicado conforme formos integrando os elementos. Ao final, irei disponibilizar links para artigos específicos que explicam sobre cada ferramenta de forma detalhada, bem como a forma de instalação.

Criando a aplicação em Flask

O Flask é um micro-framework web de fácil uso, o que não significa que não seja potente. Primeiro, criamos um diretório de qualquer nome, pra esse exemplo, utilizaremos “api”, segundo, criaremos um arquivo app.py (Por padrão, app é o nome utilizado para o arquivo principal do Flask) onde iremos instanciar o Flask e definirmos as rotas da API, bem como importarmos todas as dependências para tal, segue exemplo:


          
            from flask import Flask
          
          
            
          
          
            # Flask app
          
          
            app = Flask(__name__)
          
          
            
          
          
            @app.route('/api', methods=['GET'])
          
          
            def handler():
          
          
              return 'Esta é nossa API', 200
          
          
            
          
          
            if __name__ == "__main__":
          
          
              app.run(host="0.0.0.0", port=int("5000"), debug=True)

A primeira coisa que fazemos, é criarmos uma instância de nosso aplicativo Flask, de nome app, note que fazemos isso na linha 4. Após esse passo, podemos partir para configurarmos as rotas da API, para isto, utilizamos o @app.route, como pode ser observado na linha 6, o método logo após a definição da rota, será executado ao fazermos um GET neste end-point.

Testando a aplicação localmente

Antes de subirmos nossa aplicação para uma maquina virtual, vamos rodar ela localmente para nos assegurar de sua funcionalidade. Lembre-se que antes de rodar o código, é preciso que todas as dependências estejam instaladas. Abra um console e navegue para o diretório em que o arquivo previamente criado app.py está criado e execute-o utilizando comando “python3 app.py”.

A mensagem “Running on http://0.0.0.0:5000/” deve aparecer no console, indicando que seu servidor http esta rodando e pronto para receber requests, execute um GET no endpoint http://0.0.0.0:5000/api , o resultado esperado é a mensagem “Esta é nossa API” e o código http 200 indicando o sucesso do teste.

Explicando o Gunicorn

De forma resumida, o gunicorn é um servidor HTTP que será utilizado para rodar nossa aplicação, apesar do Flask já possuir um servidor http, ele não é indicado para ambientes de produção, já o gunicorn, é bem recomendado pela sua capacidade de lidar com trafego de requisições. Mais detalhes podem ser encontrados nos links ao final.

Instalando dependências e criando o arquivo requirements.txt

Teremos 3 dependências para este exemplo, uma delas, o docker, pode ser baixada e instalada a partir desse site: https://www.docker.com/. As outras dependências, precisam ser instaladas utilizando algum gerenciador de pacotes do python, eu uso o pip para este trabalho, mas fica a seu critério a escolha do gerenciador. Para instalarmos o Flask e o gunicorn, execute o comando “pip install flask gunicorn”.

Instaladas as dependências, precisamos criar um arquivo onde iremos listar as dependências de nosso projeto para ser utilizado em nosso arquivo de configuração do docker, utilizaremos o comando “pip freeze”, para exportar as dependências do ambiente em um arquivo requirements.txt.

Conteinerizando a aplicação

A conteinerização é uma excelente pratica para isolar a aplicação do resto do sistema. O docker é provavelmente a ferramenta mais popular para esta tarefa e é mais fácil do que se pensa aprender sobre ela. Sem entrar em muitos detalhes, será criada uma imagem de nossa aplicação mediante um arquivo de configuração, este arquivo é o dockerfile, onde iremos especificar todos os passos a serem seguidos pelo docker para executar a virtualização, segue exemplo:


          
            FROM python:3
          
          
            COPY . /work
          
          
            WORKDIR /work
          
          
            
          
          
            EXPOSE 5000
          
          
            
          
          
            RUN pip install --no-cache-dir -r requirements.txt
          
          
            
          
          
            CMD gunicorn --workers 2 --bind 0.0.0.0:5000 app:app

Nas linhas 1–3 criamos nosso ambiente de execução, definindo o python3 como ambiente de execução e copiando todos os arquivos da aplicação para um diretório “work”. Na linha 5, dizemos para o docker expôr a porta 5000. Na linha 7, instalamos todos as dependências da nossa aplicação. Na ultima linha, rodamos nossa aplicação utilizando o Gunicorn.

Com nosso arquivo de configuração do docker pronto, vamos montar a imagem, no diretório do projeto, execute o seguinte comando: “docker build --tag my-api .”, este comando irá montar a imagem com o nome “my-api”. Para testarmos se a imagem está funcionando, execute o comando “docker run --name app -p 5000:5000 my-api”, este comando ira rodar a imagem e como resultado devemos ser capazes de executar o mesmo request feito anteriormente no endpoint http://0.0.0.0:5000/api.

Como ultimo passo, devemos salvar a imagem em um arquivo para que possamos enviar para maquina virtual na AWS, para isto, utilizamos o comando: “docker save my-api api.tar”, se tudo correr bem, teremos um arquivo “api.tar” no diretório que o comando foi executado, este arquivo é nossa imagem e devemos envia-la para maquina virtual.

Enviando para EC2 na AWS e rodando a aplicação.

Precisamos passar o arquivo que criamos previamente para uma instância da AWS, caso você não saiba fazer isso, recomendo este artigo, https://adrianorosa.com/blog/aws/criar-instancia-na-amazon-aws.html , é muito completo e explicativo. Basicamente, precisamos subir a instância do EC2, salvarmos as credenciais de conexão, enviarmos o arquivo da imagem “api.tar” para a instância utilizando SCP, conectarmos nela utilizando SSH, carregarmos a imagem e rodarmos ela.

Ao enviarmos o arquivo para a VM, precisaremos carregar a imagem salva no arquivo diretamente na maquina. Certifique-se de instalar o docker na maquina antes de prosseguir. No diretório que se encontra o arquivo, rode o seguinte comando: “docker load --input api.tar”, isto irá criar a imagem na VM e a deixará pronta para ser executada. Execute a imagem utilizando o comando “docker run --name app -p 5000:5000 my-api” que vimos antes.

Se tudo correr bem, nossa imagem já estará rodando em nossa maquina virtual e pronta para receber requests externos. Tente executar um request no endpoint que definimos anteriormente, mas, utilizando o endereço da maquina virtual, que pode ser encontrado na descrição da instância como: “Public DNS (IPv4)”, por exemplo: “ec2–38–85–219–127.compute-1.amazonaws.com:5000/api”, novamente, se tudo estiver certo, devemos receber a mensagem “Esta é nossa API” e o código http 200 indicando o sucesso do teste.

Conclusão

Agora você já tem uma breve noção de alguns dos principais detalhes de arquitetura ao criar uma API. Muitas coisas podem ser criadas a partir disso, procure ler os artigos indicados e a estudar mais afundo cada aspecto que foi explicado e, certamente, em pouco tempo você estará apto a desenvolver projetos cada vez mais complexos e relevantes.

Links úteis e referencias

Como criar uma instância EC2 na AWS: https://adrianorosa.com/blog/aws/criar-instancia-na-amazon-aws.html
Entendendo o Flask: http://pythonclub.com.br/what-the-flask-pt-1-introducao-ao-desenvolvimento-web-com-python.html
Como servir aplicativos utilizando Flask, gunicorn e ngnix: https://www.digitalocean.com/community/tutorials/how-to-serve-flask-applications-with-gunicorn-and-nginx-on-ubuntu-18-04-pt#passo-6-%E2%80%94-protegendo-o-aplicativo
Gunicorn: https://gunicorn.org/
AWS: https://aws.amazon.com/pt/
Docker: https://www.docker.com/
Conectando e enviando arquivos para uma instância EC2: https://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html
Hello World com docker: https://www.devmedia.com.br/hello-world-com-docker/40174
Como instalar e configurar o docker no Ubunto: https://www.hostinger.com.br/tutoriais/install-docker-ubuntu

Learn

Support

More Options