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:
- Python versão 3 ou superior
- MySQL Workbench
- Pacotes pip e virtualenv do Python instalados
- Um editor de código
- Uma conta no Bitbucket, GitHub ou GitLab para hospedar seu repositório Git
- Uma conta MyKinsta (inscrição gratuita) para servir o aplicativo
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:
venvScriptsactivateno Windowssource venv/bin/activateno 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:
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:
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:
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:
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.txtO 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.1Você 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 gunicornDepois 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.0Para 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.wsgiEssa 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
.envIsso 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)
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:
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:
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.
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:
Agora, mesmo quando você reconstruir seu aplicativo após aprimoramentos futuros, os detalhes da conexão com o banco de dados permanecerão.
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 is a Technical Editor at Kinsta who began his writing career as a print journalist, chasing ambulances and fire trucks. He has been covering Internet-related technology since the late 1990s.
Deixe um comentário