Python é uma das linguagens de desenvolvimento mais populares. Sua sintaxe simples e as baixas barreiras de entrada tornam uma excelente escolha para programadores iniciantes que desejam se destacar no cenário de desenvolvimento de software.

Vários frameworks e bibliotecas facilitam configurar e executar um aplicativo Python. Entre eles estão Django, FastAPI e Flask. O framework Flask atrai desenvolvedores Python por oferecer suporte à prototipagem fácil e personalização.

Este artigo prático demonstra como você pode desenvolver um aplicativo Python simples conectado a um banco de dados usando o Flask.

Aplicativos Python simplificado com Flask

Desenvolvido em 2010, Flask é muito adequado para o desenvolvimento de aplicativos web em Python graças à sua facilidade de uso e flexibilidade. Sua arquitetura enxuta concentra-se em fornecer o básico, facilitando a adição de bibliotecas para as funcionalidades necessárias. Essa abordagem torna o Flask ideal para vários projetos, desde aplicativos simples até sistemas complexos.

O Flask oferece várias ferramentas e recursos para dar suporte ao desenvolvimento de aplicativos web, incluindo:

  • Bibliotecas e ferramentas para gerenciar solicitações e respostas HTTP
  • A capacidade de rotear solicitações para funções designadas
  • Suporte para templates de renderização
  • Suporte para bancos de dados
  • Sistemas de autenticação e autorização

Como criar seu aplicativo Python com Flask

Você pode explorar os benefícios do uso do Flask para o desenvolvimento de aplicativos web criando um aplicativo Python usando o Flask. Em seguida, você pode criar e implantar o aplicativo usando o serviço de hospedagem de aplicativos web da Kinsta e conectá-lo a um banco de dados na plataforma Kinsta.

Pré-requisitos do aplicativo Python Flask

Para seguir este tutorial, você precisará de:

Instale o Flask para Python

Vá para o terminal (Linux ou macOS) ou para o prompt de comando (Windows). Comece criando um diretório chamado flask_demo.

Mude para o novo diretório e crie um ambiente virtual Python usando o comando python3 -m venv venv. Nesse caso, também estamos usando venv como o nome do diretório que dará suporte ao ambiente virtual.

Ative o ambiente virtual usando um destes comandos:

  • venvScriptsactivate no Windows
  • source venv/bin/activate no Linux ou no macOS

Agora, instale o Flask usando o pip, executando pip install flask.

O trabalho que você fez no terminal até agora deve ser parecido com o seguinte:

Terminal output during creation of a Python virtual environment and installing Flask.
Criando a base de um aplicativo Python Flask no terminal.

Crie um aplicativo base

Em seguida, crie o aplicativo básico e analise sua funcionalidade renderizando conteúdo para o navegador.

No diretório flask_demo, crie um arquivo chamado demo.py e adicione o seguinte código:

from flask import Flask

app = Flask(__name__)

# Routes
@app.route('/')
def index():
    return "Happy Coding!"

if __name__ == '__main__':
    app.run(debug=True)

Esse código importa o Flask do módulo flask e cria uma instância dele chamada app. Em seguida, o código cria uma rota que retorna o texto que exibe “Happy Coding!” quando os usuários visitam o aplicativo em um navegador. Por fim, ele executa o servidor de desenvolvimento quando o script é iniciado.

Inicie o aplicativo executando flask --app demo run no terminal. O sinalizador --app especifica o local do aplicativo que será executado – aqui, o arquivo demo.py.

Como adicionar templates ao seu aplicativo Python Flask

Ao adicionar templates ao seu aplicativo, você estará reforçando o conteúdo. Primeiro, crie um diretório chamado templates na raiz do seu aplicativo. Em seguida, vá para o diretório de templates e crie um arquivo chamado index.html que contenha o seguinte código HTML:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HomePage</title>
</head>
<body>
    <h3>Flask Demo Application</h3>
    <p>My name is John Doe - learning about Application Deployment!</p>
</body>
</html>

Em demo.py, importe render_template do módulo do flask e renderize o template index.html na função route desta forma:

from flask import Flask, render_template

app = Flask(__name__)

# Routes
@app.route('/')
def index():
    return render_template('index.html')

if __name__ == '__main__':
    app.run(debug=True)

Em seguida, sirva seu aplicativo executando flask --app demo run em seu ambiente local. Use o endereço local informado no terminal para iniciar o aplicativo em seu navegador. Você deverá ver algo parecido com isso:

Screenshot of a web browser displaying the initial stage of the Flask application.
O início de um aplicativo Python Flask em um navegador web.

Como conectar seu aplicativo Flask a um banco de dados local

Você criará uma conexão com um banco de dados local – MySQL – que armazena o conteúdo do aplicativo.

Para conectar seu aplicativo Flask ao MySQL, instale o seguinte:

  • flask_mysqldb, o conector MySQL para o Flask, usando pip install flask_mysqldb
  • Python-dotenv, para leitura de variáveis de ambiente, usando pip install python-dotenv
  • O conector Python MySQL, usando pip install mysql-connector-python
  • A dependência do MySQL, usando pip install mysqlclient

Vá para o MySQL Workbench para criar um banco de dados. Certifique-se de que você adicionou um usuário de banco de dados com permissões para acessar o banco de dados e criar tabelas.

Crie um arquivo .env no diretório raiz do seu aplicativo para manter os detalhes da conexão do banco de dados. Você adicionaria as credenciais de usuário do banco de dados e o nome do banco de dados a esse template:

DB_HOST="localhost"
DB_USER="your-db-user"
DB_PASSWORD="your-db-password"
DB_NAME="your-db-name"

Em um script demo.py revisado, agora importaremos o conector MySQL e usaremos o Python-dotenv para ler as chaves da variável de ambiente no arquivo .env. Esse novo script demo.py também verifica a existência de uma tabela chamada persons no banco de dados e a criará e preencherá se ela não existir.

import os
from flask import Flask, render_template
from flask_mysqldb import MySQL

from dotenv import load_dotenv
load_dotenv()

app = Flask(__name__)

app.config['MYSQL_HOST'] = os.getenv("DB_HOST")
app.config['MYSQL_USER'] = os.getenv("DB_USER")
app.config['MYSQL_PASSWORD'] = os.getenv("DB_PASSWORD")
app.config['MYSQL_DB'] = os.getenv("DB_NAME")

mysql = MySQL(app)

@app.route('/')
def index():
    cursor = mysql.connection.cursor()

    cursor.execute("SHOW TABLES LIKE 'persons'")
    result = cursor.fetchone()

    if not result:
        cursor.execute(''' CREATE TABLE persons (id INTEGER, firstname VARCHAR(20), lastname VARCHAR(20)) ''')
        cursor.execute(''' INSERT INTO persons VALUES(1, 'John', 'Doe') ''')
        cursor.execute(''' INSERT INTO persons VALUES(2, 'Milly', 'Winfrerey') ''')
        mysql.connection.commit()

    cursor.execute('SELECT * FROM persons')
    entry = cursor.fetchall()
    cursor.close()
    return render_template('index.html', entry=entry)

Depois de instanciar o Flask, o código acima usa variáveis de ambiente para capturar os atributos do banco de dados do arquivo .env na raiz do seu aplicativo.

Em seguida, o código instancia o MySQL e o associa ao Flask. Ele cria um objeto de cursor na rota index. Em seguida, o código verifica se há uma tabela chamada persons no banco de dados. Se ela não for encontrada, ele a cria com os atributos id, firstname e lastname e insere duas linhas de dados.

As próximas três linhas executam um comando SQL para selecionar todas as linhas da tabela persons e buscar os resultados. O objeto cursor é fechado e os resultados da consulta são passados como a variável de contexto entry para renderização com o template.

Aqui está um arquivo template index.html revisado, capaz de processar os resultados obtidos através de consultas ao banco de dados:

<!DOCTYPE html><html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HomePage</title>
</head>
<body>
    <h3>Flask Demo Application</h3>
    {% for e in entry %}
        <p>My name is {{e[1]}} {{e[2]}} - learning about Application Deployment!</p>
    {% endfor %}
</body>
</html>

Execute o aplicativo e, em seguida, retorne ao MySQL Workbench para verificar os dados. Você deve se parecer com o seguinte:

Screenshot of query results in MySQL Workbench.
Resultados da consulta para a tabela persons no MySQL Workbench.

Quando você consulta a tabela, as duas entradas geradas pelo aplicativo são retornadas. Agora, seu aplicativo renderiza o seguinte conteúdo derivado do banco de dados no navegador:

Screenshot showing content generated from the database.
Conteúdo gerado pelo banco de dados no navegador.

Como implantar seu aplicativo Python Flask na Kinsta

Agora que seu aplicativo está em funcionamento localmente, você pode torná-lo visível para o mundo hospedando na Kinsta. Você pode combinar os serviços de Hospedagem de Aplicativos Web e Hospedagem de Banco de Dados Gerenciado da Kinsta para dar vida a esse aplicativo na nuvem. E você pode experimentar os dois gratuitamente.

Preparando seu projeto Python para implantação

A plataforma de Hospedagem de Aplicativos Web da Kinsta implanta seu código a partir do seu provedor Git favorito. Seu próximo passo é configurar o ambiente do seu aplicativo para suportar esse caminho e permitir que a Kinsta implemente seu aplicativo com todas as dependências necessárias.

Comece criando um novo diretório na raiz do projeto flask_demo. Vamos chamá-lo de myapp. Em seguida, mova o diretório de templates e o arquivo demo.py para myapp.

Dentro do diretório myapp, crie um arquivo wsgi.py com o seguinte conteúdo:

from myapp.demo import app as application

if __name__ == "__main__":
    application.run(debug=True)

O processo de build na Kinsta também usará o pip para gerar seu aplicativo. Você pode passar uma lista das dependências do seu aplicativo para o pip no lado da produção usando um arquivo requirements.txt no diretório raiz do projeto.

Enquanto ainda estiver trabalhando no ambiente virtual venv e dentro do diretório raiz do flask_demo, você pode gerar um arquivo requirements.txt específico para o seu projeto com o seguinte comando:

pip freeze > requirements.txt

O conteúdo do arquivo de texto resultante será parecido com o seguinte:

blinker==1.7.0
click==8.1.7
Flask==3.0.0
Flask-MySQLdb==2.0.0
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
mysql-connector-python==8.2.0
mysqlclient==2.2.1
protobuf==4.21.12
python-dotenv==1.0.0
Werkzeug==3.0.1

Você não enviará o arquivo .env com os segredos do banco de dados para o servidor de produção. Como você não precisará da biblioteca python-dotenv para ler o .env na produção, poderá remover sua referência do requirements.txt e remover (ou comentar) essas linhas no demo.py:

from dotenv import load_dotenv
load_dotenv()

Adicione um servidor HTTP Python WSGI ao projeto

Uma coisa que falta nos requisitos acima é uma maneira de servir o aplicativo via HTTP em um ambiente de produção. O servidor de desenvolvimento usado em sua máquina local não será suficiente. Para este projeto, você usará o pacote Gunicorn da Web Server Gateway Interface (WSGI) entre o aplicativo e os servidores web Nginx da Kinsta.

Você pode adicionar um requisito do Gunicorn ao seu projeto instalando em seu ambiente virtual desta forma:

pip install gunicorn

Depois que o Gunicorn for instalado, use o pip para gerar o requirements.txt novamente.

Uma alternativa para instalar o Gunicorn localmente é editar o requirements.txt e simplesmente adicionar uma entrada como esta:

gunicorn==21.2.0

Para concluir o trabalho de base para o servidor WSGI, crie um arquivo no diretório raiz do projeto chamado Procfile e adicione a seguinte linha:

web: gunicorn myapp.wsgi

Essa será a base do comando start do seu aplicativo em produção.

Preparando seu projeto para o Git

A estrutura de diretórios revisada está pronta para ser implantada na Kinsta, mas você não quer que todos esses arquivos entrem em produção. Crie um arquivo .gitignore na raiz do projeto com conteúdo como este:

/venv
.env

Isso evitará que os arquivos no diretório venv e os segredos do banco de dados local em .env sejam carregados no provedor Git.

Agora você pode iniciar seu ambiente Git local e enviar o código para o provedor Git usando as ferramentas de sua preferência.

Implante seu aplicativo Python Flask na Kinsta

Faça login no seu painel MyKinsta e certifique-se de que você autorizou a Kinsta para acessar seu provedor de serviços Git. Siga as etapas para adicionar um aplicativo, selecionando o repositório e a branch no provedor Git onde a Kinsta encontrará esse código de projeto Flask.

Ao configurar o ambiente de build, selecione Usar Buildpacks para configurar a imagem do contêiner, mas deixe todas as outras configurações como padrão. (Você não fornecerá um comando start porque já vem definido em seu Procfile)

Screenshot of the MyKinsta interface for configuring a build environment.
Escolhendo Buildpacks para configurar a imagem do contêiner para o aplicativo.

Depois de revisar as informações de cobrança (você ainda pode começar gratuitamente!), clique no botão Implantar agora e observe o progresso no visualizador de registros:

Screenshot of the log entries for a Python Flask app deployment.
Entradas de registro para a implantação do seu aplicativo Python Flask.

Adicionando um banco de dados para o seu aplicativo Python Flask

A Kinsta tem quatro opções de bancos de dados gerenciados para atender às suas necessidades e requisitos de aplicativos: Redis, PostgreSQL, MariaDB e MySQL. Para este tutorial, estamos construindo para o serviço de banco de dados MySQL.

Siga as instruções oficiais para adicionar um banco de dados, lembrando-se de selecionar o mesmo centro de dados que você escolheu para o seu aplicativo Flask.

Depois de criar o banco de dados, selecione na lista de servidores de banco de dados disponíveis e role para baixo até a seção Conexões internas / Aplicativos permitidos da aba Visão geral. Quando você clicar no botão Adicionar conexão, o serviço do aplicativo Flask no mesmo centro de dados estará disponível para seleção:

Screenshot of the dialog for adding an internal database connection in MyKinsta.
Adicionando uma conexão interna a um aplicativo depois de criar um banco de dados.

Clique na caixa de seleção Adicionar variáveis de ambiente ao aplicativo antes de criar a nova conexão. Isso exibe as variáveis de ambiente que conterão os segredos do seu banco de dados – tudo tratado com segurança sem a necessidade do arquivo .env.

Screenshot of the dialog for adding environment variables for database credentials.
Adicionando variáveis de ambiente para uma conexão interna ao seu banco de dados.

Na parte inferior da caixa de diálogo acima, as configurações Disponível durante o tempo de execução e Disponível durante o processo de build serão ativadas por padrão – e é exatamente isso que você deseja.

Depois que você finalmente clicar no botão Adicionar conexão, as variáveis de ambiente necessárias para o acesso ao banco de dados serão aplicadas às Configurações do seu projeto no painel Aplicativos do MyKinsta:

Screenshot of a MyKinsta dialog showing environment variables passed from the database to an application.
Variáveis de ambiente do banco de dados passadas para o aplicativo Python Flask.

Agora, mesmo quando você reconstruir seu aplicativo após aprimoramentos futuros, os detalhes da conexão com o banco de dados permanecerão.

Screenshot of the Python Flask application live on the Kinsta platform.
O aplicativo Python Flask está ativo na plataforma Kinsta.

Parabéns! Você acabou de criar um aplicativo Python Flask e implantá-lo na plataforma Kinsta.

Resumo

A framework personalizável do Flask torna a criação de um aplicativo Python muito mais simples. Usar a Kinsta para implantar um aplicativo Flask torna as coisas ainda mais fáceis, acelerando o desenvolvimento e a implantação de aplicativos.

Aqui, aprendemos como criar um aplicativo simples conectado a um banco de dados em um ambiente de desenvolvimento local e, em seguida, disponibilizá-lo para o resto do mundo nas plataformas de hospedagem de aplicativos web e hospedagem de banco de dados da Kinsta.

Explore o que mais você pode criar em nossa plataforma navegando em nossos Templates de Início Rápido.

Steve Bonisteel Kinsta

Steve Bonisteel é um Editor Técnico na Kinsta que começou sua carreira de escritor como jornalista impresso, cobrindo ambulâncias e caminhões de bombeiros. Ele tem coberto tecnologia relacionada à Internet desde o final dos anos 1990.