Crie uma API REST em Flask com SQLite | Tutorial de Programação

Introdução

Neste projeto, aprenderemos como construir uma API REST em Flask usando SQLite como banco de dados. Começaremos criando um banco de dados SQLite de exemplo e preenchendo-o com alguns dados. Em seguida, construiremos uma aplicação Flask com endpoints para realizar operações CRUD (Create, Read, Update, Delete) nos dados do banco de dados SQLite.

👀 Pré-visualização

Flask SQLite API preview

🎯 Tarefas

Neste projeto, você aprenderá:

Como criar uma aplicação Flask com SQLite como backend de banco de dados
Como criar um banco de dados e tabela SQLite de exemplo
Como preencher a tabela do banco de dados com dados de exemplo
Como implementar endpoints para recuperar todos os usuários, recuperar um usuário específico por ID, criar um novo usuário, atualizar um usuário existente e excluir um usuário
Como testar os endpoints da API REST usando cURL ou um navegador

🏆 Conquistas

Após concluir este projeto, você será capaz de:

Construir uma aplicação Flask com SQLite como banco de dados
Realizar operações CRUD em dados em um banco de dados SQLite usando Flask
Implementar e testar endpoints de API REST para uma aplicação Flask

Criar os arquivos do projeto

Vamos começar criando os arquivos de projeto necessários para nossa aplicação Flask.

cd para o diretório ~/project.
Dentro do diretório do projeto, crie um novo arquivo Python chamado app.py.
Crie um novo arquivo chamado create_database.py no mesmo diretório.

cd ~/project
touch app.py create_database.py

A estrutura do seu projeto deve ser semelhante a esta:

project/
├── app.py
└── create_database.py

Criar um banco de dados SQLite de exemplo

Em seguida, vamos criar um banco de dados SQLite e preenchê-lo com dados de exemplo usando Python e a biblioteca SQLite.

No arquivo create_database.py, adicione o seguinte código para importar os módulos necessários:

import sqlite3

Adicione o seguinte código para criar o banco de dados e a tabela:

## Create a connection to the database
conn = sqlite3.connect('example.db')

## Create a cursor object to execute SQL statements
cursor = conn.cursor()

## Create a table called "users"
cursor.execute('''CREATE TABLE IF NOT EXISTS users (
                    id INTEGER PRIMARY KEY,
                    name TEXT,
                    email TEXT
                )''')

Em seguida, vamos inserir alguns dados de exemplo na tabela:

## Insert sample data into the "users" table
users = [
    ('John Doe', 'johndoe@example.com'),
    ('Jane Smith', 'janesmith@example.com'),
    ('Bob Johnson', 'bobjohnson@example.com')
]
cursor.executemany('INSERT INTO users (name, email) VALUES (?, ?)', users)

## Commit the changes to the database
conn.commit()

## Close the cursor and the database connection
cursor.close()
conn.close()

cd ~/project
python create_database.py

Após executar este código, você terá um arquivo de banco de dados SQLite chamado example.db com a tabela "users" contendo os dados de exemplo. Este banco de dados será usado em nossa aplicação Flask para recuperar e manipular dados.

Construir uma API REST em Flask

Agora, vamos construir uma API REST em Flask usando o banco de dados SQLite example.db que criamos anteriormente.

No arquivo app.py, adicione o seguinte código para importar os módulos necessários:

from flask import Flask, jsonify, request
import sqlite3

Adicione o seguinte código para criar a aplicação Flask:

## Create the Flask application
app = Flask(__name__)

Agora, vamos definir os endpoints para nossa API REST:

Endpoint para recuperar todos os usuários

## Endpoint to retrieve all users
@app.route('/users', methods=['GET'])
def get_users():
    ## Connect to the database
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()

    ## Execute the SQL query to retrieve all users
    cursor.execute('SELECT * FROM users')
    users = cursor.fetchall()

    ## Close the cursor and the database connection
    cursor.close()
    conn.close()

    ## Return the users as JSON
    return jsonify(users)

Neste código, primeiro conectamos ao banco de dados SQLite usando o método connect(). Em seguida, criamos um objeto cursor para executar as instruções SQL usando o método cursor(). Depois, executamos a consulta SQL para recuperar todos os usuários da tabela "users" usando o método execute(). Finalmente, fechamos o cursor e a conexão com o banco de dados usando o método close() e retornamos os usuários como JSON usando o método jsonify().

Endpoint para recuperar um usuário específico por ID

## Endpoint to retrieve a specific user by ID
@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    ## Connect to the database
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()

    ## Execute the SQL query to retrieve the user by ID
    cursor.execute('SELECT * FROM users WHERE id = ?', (user_id,))
    user = cursor.fetchone()

    ## Close the cursor and the database connection
    cursor.close()
    conn.close()

    ## Check if the user exists
    if user:
        return jsonify(user)
    else:
        return jsonify({'message': 'User not found'}), 404

Este endpoint é semelhante ao anterior, exceto que ele recupera um usuário específico por ID em vez de todos os usuários. Usamos o método fetchone() para recuperar um único usuário da tabela "users".

Endpoint para criar um novo usuário

## Endpoint to create a new user
@app.route('/users', methods=['POST'])
def create_user():
    ## Get the user data from the request body
    data = request.get_json()
    name = data['name']
    email = data['email']

    ## Connect to the database
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()

    ## Execute the SQL query to insert a new user
    cursor.execute('INSERT INTO users (name, email) VALUES (?, ?)', (name, email))
    conn.commit()

    ## Close the cursor and the database connection
    cursor.close()
    conn.close()

    ## Return a success message
    return jsonify({'message': 'User created successfully'})

Este endpoint é usado para criar um novo usuário na tabela "users". Usamos o método get_json() para obter os dados do usuário do corpo da requisição. Em seguida, usamos o método execute() para inserir o novo usuário na tabela "users".

Endpoint para atualizar um usuário existente

## Endpoint to update an existing user
@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    ## Get the updated user data from the request body
    data = request.get_json()
    name = data['name']
    email = data['email']

    ## Connect to the database
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()

    ## Execute the SQL query to update the user
    cursor.execute('UPDATE users SET name = ?, email = ? WHERE id = ?', (name, email, user_id))
    conn.commit()

    ## Close the cursor and the database connection
    cursor.close()
    conn.close()

    ## Return a success message
    return jsonify({'message': 'User updated successfully'})

Este endpoint é usado para atualizar um usuário existente na tabela "users". Usamos o método get_json() para obter os dados atualizados do usuário do corpo da requisição. Em seguida, usamos o método execute() para atualizar o usuário na tabela "users".

Endpoint para deletar um usuário

## Endpoint to delete a user
@app.route('/users/<int:user_id>', methods=['DELETE'])
def delete_user(user_id):
    ## Connect to the database
    conn = sqlite3.connect('example.db')
    cursor = conn.cursor()

    ## Execute the SQL query to delete the user
    cursor.execute('DELETE FROM users WHERE id = ?', (user_id,))
    conn.commit()

    ## Close the cursor and the database connection
    cursor.close()
    conn.close()

    ## Return a success message
    return jsonify({'message': 'User deleted successfully'})

Este endpoint é usado para deletar um usuário da tabela "users". Usamos o método execute() para deletar o usuário da tabela "users".

Finalmente, vamos adicionar o seguinte código para executar a aplicação Flask:

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=8080)

Executar a aplicação Flask

Para executar o projeto e iniciar a aplicação Flask, abra um terminal ou prompt de comando, navegue até o diretório do projeto e execute o seguinte comando:

cd ~/project
python app.py

Você deverá ver uma saída semelhante à seguinte:

* Serving Flask app 'app' (lazy loading)
* Environment: production
WARNING: This is a development server. Do not use it in a production deployment.
Use a production WSGI server instead.
* Debug mode: on
* Running on http://0.0.0.0:8080/ (Press CTRL+C to quit)

Isso significa que a aplicação Flask está rodando localmente em sua máquina. Agora você pode testar os endpoints da API REST usando uma ferramenta como cURL ou uma ferramenta de teste de API como Postman.

Testar os endpoints da API REST

Abra um novo terminal ou prompt de comando.
Use os seguintes comandos cURL para testar cada endpoint:

Recuperar todos os usuários:

curl http://localhost:8080/users

Recuperar um usuário específico por ID (substitua <user_id> por um ID de usuário real):

curl http://localhost:8080/users/<user_id>

Criar um novo usuário:

curl -X POST -H "Content-Type: application/json" -d '{"name":"John Doe","email":"johndoe@example.com"}' http://localhost:8080/users

Atualizar um usuário existente (substitua <user_id> por um ID de usuário real):

curl -X PUT -H "Content-Type: application/json" -d '{"name":"Updated Name","email":"updated@example.com"}' http://localhost:8080/users/<user_id>

Deletar um usuário (substitua <user_id> por um ID de usuário real):

curl -X DELETE http://localhost:8080/users/<user_id>

Certifique-se de substituir <user_id> pelo ID real de um usuário no banco de dados ao testar os endpoints correspondentes.

Ao executar esses comandos cURL, você pode testar a funcionalidade dos endpoints da API REST e verificar se eles estão funcionando corretamente.

Alternativamente, você pode mudar para a aba Web 8080 para testar os endpoints da API REST usando o navegador.

Interface de teste da API REST

Com estas etapas de teste, você pode garantir que a aplicação Flask e seus endpoints da API REST estão funcionando conforme o esperado.

Resumo

Neste projeto, aprendemos como construir uma API REST em Flask com SQLite como banco de dados. Criamos um banco de dados SQLite de exemplo e o preenchemos com dados. Em seguida, construímos uma aplicação Flask com endpoints para recuperar, criar, atualizar e deletar usuários do banco de dados. Seguindo as instruções passo a passo, você agora deve ter uma aplicação Flask funcional que fornece uma API REST para interagir com o banco de dados SQLite.

Construindo uma API REST em Flask com SQLite