Hoe een PostgreSQL-database te gebruiken in een Flask-toepassing

Handleidingen
Flask PostgreSQL Python

De auteur heeft het Free and Open Source Fund geselecteerd om een donatie te ontvangen als onderdeel van het Write for DOnations-programma.

Inleiding

In webapplicaties heb je meestal een database nodig, wat een georganiseerde verzameling gegevens is. Je gebruikt een database om persistente gegevens op te slaan en te onderhouden die efficiënt kunnen worden opgehaald en bewerkt. Bijvoorbeeld, in een social media applicatie heb je een database waar gebruikersgegevens (persoonlijke informatie, berichten, opmerkingen, volgers) worden opgeslagen op een manier die efficiënt kan worden bewerkt. Je kunt gegevens aan een database toevoegen, deze ophalen, wijzigen of verwijderen, afhankelijk van verschillende vereisten en voorwaarden. In een webapplicatie kunnen deze vereisten zijn dat een gebruiker een nieuw bericht toevoegt, een bericht verwijdert of zijn account verwijdert, waarbij zijn berichten mogelijk al dan niet worden verwijderd. De handelingen die je uitvoert om gegevens te manipuleren, zullen afhangen van specifieke functies in je applicatie. Bijvoorbeeld, je wilt misschien niet dat gebruikers berichten toevoegen zonder titels.

Flask is een lichtgewicht Python-webframework dat handige tools en functies biedt voor het maken van webapplicaties in de Python-taal. PostgreSQL, of Postgres, is een relationeel databasesysteem dat een implementatie van de SQL querytaal biedt. Het is conform de standaarden en heeft vele geavanceerde functies zoals betrouwbare transacties en gelijktijdigheid zonder leesvergrendelingen.

In deze tutorial bouw je een kleine webapplicatie voor het beoordelen van boeken die laat zien hoe je de psycopg2 bibliotheek gebruikt, een PostgreSQL database-adapter waarmee je kunt communiceren met je PostgreSQL-database in Python. Je zult het gebruiken met Flask om basisfuncties uit te voeren, zoals het verbinden met een databaseserver, tabellen maken, gegevens invoegen in een tabel en gegevens ophalen uit een tabel.

Vereisten

Stap 1 — Het maken van de PostgreSQL-database en gebruiker

In deze stap maakt u een database genaamd flask_db en een databasegebruiker genaamd sammy voor uw Flask-toepassing.

Tijdens de installatie van Postgres werd een besturingssysteemgebruiker met de naam postgres aangemaakt om overeen te komen met de PostgreSQL-beheerdersgebruiker postgres. U moet deze gebruiker gebruiken om administratieve taken uit te voeren. U kunt sudo gebruiken en de gebruikersnaam doorgeven met de optie -iu.

Log in op een interactieve Postgres-sessie met de volgende opdracht:

  1. sudo -iu postgres psql

U krijgt een PostgreSQL-prompt waar u aan uw vereisten kunt voldoen.

Maak eerst een database voor uw project:

  1. CREATE DATABASE flask_db;

Opmerking: Elke PostgreSQL-opdracht moet eindigen met een puntkomma, dus zorg ervoor dat uw opdracht eindigt met een als u problemen ondervindt.

Vervolgens maakt u een databasegebruiker voor ons project aan. Zorg ervoor dat u een veilig wachtwoord kiest:

  1. CREATE USER sammy WITH PASSWORD 'password';

Vervolgens geeft u deze nieuwe gebruiker toegang om uw nieuwe database te beheren:

  1. GRANT ALL PRIVILEGES ON DATABASE flask_db TO sammy;

Om te bevestigen dat de database is aangemaakt, krijgt u de lijst met databases door het volgende commando in te typen:

  1. \l

U ziet flask_db in de lijst met databases.

Wanneer u klaar bent, verlaat u de PostgreSQL-prompt door het volgende in te typen:

  1. \q

Postgres is nu ingesteld zodat u verbinding kunt maken met en het database-informatie kunt beheren via Python met behulp van de psycopg2-bibliotheek. Vervolgens installeert u deze bibliotheek naast het Flask-pakket.

Stap 2 — Flask en psycopg2 installeren

In deze stap installeert u Flask en de psycopg2-bibliotheek zodat u kunt communiceren met uw database met behulp van Python.

Met uw virtuele omgeving geactiveerd, gebruikt u pip om Flask en de psycopg2-bibliotheek te installeren:

  1. pip install Flask psycopg2-binary

Zodra de installatie succesvol is voltooid, ziet u een regel vergelijkbaar met de volgende aan het einde van de uitvoer:

Output

Successfully installed Flask-2.0.2 Jinja2-3.0.3 MarkupSafe-2.0.1 Werkzeug-2.0.2 click-8.0.3 itsdangerous-2.0.1 psycopg2-binary-2.9.2

U heeft nu de vereiste pakketten geïnstalleerd in uw virtuele omgeving. Vervolgens maakt u verbinding met en stelt u uw database in.

Stap 3 — Het opzetten van een database

In deze stap maakt u een Python-bestand aan in uw projectdirectory flask_app om verbinding te maken met de database flask_db, een tabel aan te maken voor het opslaan van boeken, en enkele boeken met recensies erin in te voegen.

Eerst, met uw programmeeromgeving geactiveerd, opent u een nieuw bestand genaamd init_db.py in uw flask_app directory.

  1. nano init_db.py

Dit bestand zal een verbinding openen met de database flask_db, een tabel genaamd books aanmaken, en de tabel vullen met voorbeeldgegevens. Voeg de volgende code toe:

flask_app/init_db.py
import os
import psycopg2

conn = psycopg2.connect(
        host="localhost",
        database="flask_db",
        user=os.environ['DB_USERNAME'],
        password=os.environ['DB_PASSWORD'])

# Open een cursor om databasebewerkingen uit te voeren
cur = conn.cursor()

# Voer een opdracht uit: dit maakt een nieuwe tabel aan
cur.execute('DROP TABLE IF EXISTS books;')
cur.execute('CREATE TABLE books (id serial PRIMARY KEY,'
                                 'title varchar (150) NOT NULL,'
                                 'author varchar (50) NOT NULL,'
                                 'pages_num integer NOT NULL,'
                                 'review text,'
                                 'date_added date DEFAULT CURRENT_TIMESTAMP);'
                                 )

# Voeg gegevens toe aan de tabel

cur.execute('INSERT INTO books (title, author, pages_num, review)'
            'VALUES (%s, %s, %s, %s)',
            ('A Tale of Two Cities',
             'Charles Dickens',
             489,
             'A great classic!')
            )


cur.execute('INSERT INTO books (title, author, pages_num, review)'
            'VALUES (%s, %s, %s, %s)',
            ('Anna Karenina',
             'Leo Tolstoy',
             864,
             'Another great classic!')
            )

conn.commit()

cur.close()
conn.close()

Sla het bestand op en sluit het.

In dit bestand importeert u eerst de os module die u zult gebruiken om toegang te krijgen tot omgevingsvariabelen waarin u uw gebruikersnaam en wachtwoord voor de database opslaat, zodat ze niet zichtbaar zijn in uw broncode.

U importeert de psycopg2 bibliotheek. Vervolgens opent u een verbinding met de flask_db database met behulp van de psycopg2.connect() functie. U specificeert de host, die in dit geval localhost is. U geeft de databasenaam door aan de database parameter.

U verstrekt uw gebruikersnaam en wachtwoord via het os.environ object, dat toegang geeft tot omgevingsvariabelen die u hebt ingesteld in uw programmeeromgeving. U slaat de gebruikersnaam van de database op in een omgevingsvariabele genaamd DB_USERNAME en het wachtwoord in een omgevingsvariabele genaamd DB_PASSWORD. Dit stelt u in staat om uw gebruikersnaam en wachtwoord buiten uw broncode op te slaan, zodat uw gevoelige informatie niet wordt gelekt wanneer de broncode wordt opgeslagen in versiebeheer of geüpload naar een server op het internet. Zelfs als een aanvaller toegang krijgt tot uw broncode, krijgen ze geen toegang tot de database.

U maakt een cursor genaamd cur aan met behulp van de connection.cursor() methode, waarmee Python-code PostgreSQL-opdrachten kan uitvoeren in een databasesessie.

U gebruikt de execute() methode van de cursor om de tabel books te verwijderen als deze al bestaat. Dit voorkomt de mogelijkheid dat er een andere tabel met de naam books bestaat, wat tot verwarrend gedrag zou kunnen leiden (bijvoorbeeld als deze verschillende kolommen heeft). Dit is hier niet het geval, omdat u de tabel nog niet heeft aangemaakt, dus het SQL-commando wordt niet uitgevoerd. Let op: dit zal alle bestaande gegevens verwijderen telkens wanneer u dit init_db.py bestand uitvoert. Voor onze doeleinden zult u dit bestand slechts één keer uitvoeren om de database te initiëren, maar u wilt het mogelijk opnieuw uitvoeren om alle ingevoegde gegevens te verwijderen en opnieuw te beginnen met de initiële voorbeeldgegevens.

Vervolgens gebruikt u CREATE TABLE books om een tabel genaamd books aan te maken met de volgende kolommen:

  • id: Een ID van het type serial, wat een automatisch toenemend geheel getal is. Deze kolom vertegenwoordigt een primaire sleutel die u specificeert met de sleutelwoorden PRIMARY KEY. De database zal voor elke invoer een unieke waarde aan deze sleutel toewijzen.
  • title: De titel van het boek van het type varchar, wat een tekenreeks van variabele lengte met een limiet is. varchar(150) betekent dat de titel maximaal 150 tekens lang kan zijn. NOT NULL geeft aan dat deze kolom niet leeg mag zijn.
  • author: De auteur van het boek, met een limiet van 50 tekens. NOT NULL geeft aan dat deze kolom niet leeg mag zijn.
  • pages_num: Een geheel getal dat het aantal pagina’s van het boek vertegenwoordigt. NOT NULL geeft aan dat deze kolom niet leeg mag zijn.
  • review: De boekrecensie. Het text-type geeft aan dat de recensie tekst van willekeurige lengte kan zijn.
  • date_added: De datum waarop het boek aan de tabel is toegevoegd. DEFAULT stelt de standaardwaarde van de kolom in op CURRENT_TIMESTAMP, wat de tijd is waarop het boek aan de database is toegevoegd. Net als id hoef je geen waarde op te geven voor deze kolom, omdat deze automatisch wordt ingevuld.

Na het maken van de tabel gebruik je de execute()-methode van de cursor om twee boeken in de tabel in te voegen, A Tale of Two Cities van Charles Dickens, en Anna Karenina van Leo Tolstoy. Je gebruikt de %s-placeholder om de waarden door te geven aan het SQL-statement. psycopg2 handelt de invoeging op de achtergrond af op een manier die SQL Injection-aanvallen voorkomt.

Zodra je klaar bent met het invoegen van boekgegevens in je tabel, gebruik je de connection.commit()-methode om de transactie te bevestigen en de wijzigingen toe te passen op de database. Vervolgens ruim je op door de cursor te sluiten met cur.close(), en de verbinding met conn.close().

Om de databaseverbinding tot stand te brengen, stel je de omgevingsvariabelen DB_USERNAME en DB_PASSWORD in door de volgende commando’s uit te voeren. Onthoud om je eigen gebruikersnaam en wachtwoord te gebruiken:

  1. export DB_USERNAME="sammy"

  2. export DB_PASSWORD="password"

Voer nu je init_db.py-bestand uit in de terminal met het python-commando:

  1. python init_db.py

Zodra het bestand zonder fouten is uitgevoerd, wordt er een nieuwe books-tabel toegevoegd aan uw flask_db-database.

Meld u aan bij een interactieve Postgres-sessie om de nieuwe books-tabel te bekijken.

  1. sudo -iu postgres psql

Verbind met de flask_db-database met behulp van het \c-commando:

  1. \c flask_db

Gebruik vervolgens een SELECT-statement om de titels en auteurs van boeken uit de books-tabel te krijgen:

  1. SELECT title, author FROM books;

U ziet een uitvoer zoals de volgende:

        title         |      author
----------------------+------------------
 A Tale of Two Cities | Charles Dickens
 Anna Karenina        | Leo Tolstoy

Sluit de interactieve sessie af met \q.

Vervolgens maakt u een kleine Flask-toepassing, verbindt u met de database, haalt u de twee boekrecensies op die u in de database hebt ingevoegd, en geeft u ze weer op de startpagina.

Stap 4 — Boeken Weergeven

In deze stap maakt u een Flask-toepassing met een startpagina die de boeken die in de database staan, ophaalt en weergeeft.

Met uw programmeeromgeving geactiveerd en Flask geïnstalleerd, opent u een bestand met de naam app.py ter bewerking binnen uw flask_app-directory:

  1. nano app.py

In dit bestand wordt uw databaseverbinding ingesteld en wordt een enkele Flask-route gemaakt om die verbinding te gebruiken. Voeg de volgende code toe aan het bestand:

flask_app/app.py
import os
import psycopg2
from flask import Flask, render_template

app = Flask(__name__)

def get_db_connection():
    conn = psycopg2.connect(host='localhost',
                            database='flask_db',
                            user=os.environ['DB_USERNAME'],
                            password=os.environ['DB_PASSWORD'])
    return conn


@app.route('/')
def index():
    conn = get_db_connection()
    cur = conn.cursor()
    cur.execute('SELECT * FROM books;')
    books = cur.fetchall()
    cur.close()
    conn.close()
    return render_template('index.html', books=books)

Sla het bestand op en sluit het.

Hier importeer je de os-module, de psycopg2-bibliotheek, en de Flask-klasse en de render_template() van het flask-pakket. Je maakt een Flask-toepassingsinstantie genaamd app.

Je definieert een functie genaamd get_db_connection(), die een verbinding opent met de flask_db-database met behulp van de gebruikersnaam en het wachtwoord die je opslaat in je DB_USERNAME en DB_PASSWORD-omgevingsvariabelen. De functie retourneert het conn-verbindingsobject dat je zult gebruiken om toegang te krijgen tot de database.

Vervolgens maak je een hoofdroute / en een index()-weergavefunctie met behulp van de app.route()-decorator. In de index()-weergavefunctie open je een databaseverbinding met behulp van de get_db_connection()-functie, maak je een cursor aan, en voer je de SELECT * FROM books;-SQL-instructie uit om alle boeken op te halen die in de database staan. Je gebruikt de fetchall()-methode om de gegevens op te slaan in een variabele genaamd books. Vervolgens sluit je de cursor en de verbinding. Ten slotte retourneer je een oproep naar de render_template()-functie om een sjabloondbestand genaamd index.html te renderen en het de lijst met boeken door te geven die je uit de database hebt gehaald in de books-variabele.

Om de boeken die u in uw database heeft op de indexpagina weer te geven, maakt u eerst een basissjabloon aan, die alle basis-HTML-code zal bevatten die andere sjablonen ook zullen gebruiken om herhaling van code te voorkomen. Vervolgens maakt u het index.html sjabloonbestand aan dat u hebt gerenderd in uw index() functie. Om meer te weten te komen over sjablonen, zie Hoe sjablonen te gebruiken in een Flask-toepassing.

Maak een templates map, open vervolgens een nieuw sjabloon genaamd base.html:

  1. mkdir templates

  2. nano templates/base.html

Voeg de volgende code toe binnen het base.html bestand:

flask_app/templates/base.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %} {% endblock %}- FlaskApp</title>
    <style>
        nav a {
            color: #d64161;
            font-size: 3em;
            margin-left: 50px;
            text-decoration: none;
        }

        .book {
            padding: 20px;
            margin: 10px;
            background-color: #f7f4f4;
        }

        .review {
                margin-left: 50px;
                font-size: 20px;
        }

    </style>
</head>
<body>
    <nav>
        <a href="{{ url_for('index') }}">FlaskApp</a>
        <a href="#">About</a>
    </nav>
    <hr>
    <div class="content">
        {% block content %} {% endblock %}
    </div>
</body>
</html>

Sla het bestand op en sluit het.

Deze basissjabloon heeft alle HTML-boilerplate die u nodig zult hebben om te hergebruiken in uw andere sjablonen. Het title blok zal worden vervangen om een titel voor elke pagina in te stellen, en het content blok zal worden vervangen door de inhoud van elke pagina. De navigatiebalk heeft twee links, één voor de indexpagina waar u de url_for() hulpfunctie gebruikt om naar de index() weergavefunctie te linken, en de andere voor een Over pagina als u ervoor kiest om deze op te nemen in uw applicatie.

Open vervolgens een sjabloon genaamd index.html. Dit is het sjabloon waarnaar wordt verwezen in het app.py bestand:

  1. nano templates/index.html

Voeg de volgende code toe:

flask_app/templates/index.html

{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Books {% endblock %}</h1>
    {% for book in books %}
        <div class='book'>
            <h3>#{{ book[0] }} - {{ book[1] }} BY {{ book[2] }}</h3>
            <i><p>({{ book[3] }} pages)</p></i>
            <p class='review'>{{ book[4] }}</p>
            <i><p>Added {{ book[5] }}</p></i>
        </div>
    {% endfor %}
{% endblock %}

Sla het bestand op en sluit het.

In dit bestand breidt u het basissjabloon uit en vervangt u de inhoud van het content blok. U gebruikt een <h1> kop die ook dient als titel.

Je gebruikt een Jinja for loop op de regel {% for book in books %} om door elk boek in de lijst books te gaan. Je toont de boek-ID, die het eerste item is met book[0]. Vervolgens toon je de titel van het boek, de auteur, het aantal pagina’s, de recensie en de datum waarop het boek is toegevoegd.

Terwijl je in je flask_app-directory bent met je virtuele omgeving geactiveerd, vertel Flask over de applicatie (app.py in dit geval) met behulp van de FLASK_APP-omgevingsvariabele. Stel vervolgens de FLASK_ENV-omgevingsvariabele in op development om de applicatie in ontwikkelingsmodus uit te voeren en toegang te krijgen tot de debugger. Voor meer informatie over de Flask-debugger, zie Hoe fouten behandelen in een Flask-toepassing. Gebruik de volgende commando’s om dit te doen:

  1. export FLASK_APP=app

  2. export FLASK_ENV=development

Zorg ervoor dat je de DB_USERNAME– en DB_PASSWORD-omgevingsvariabelen instelt als je dat nog niet hebt gedaan:

  1. export DB_USERNAME="sammy"

  2. export DB_PASSWORD="password"

Voer vervolgens de applicatie uit:

  1. flask run

Met de ontwikkelingsserver actief, bezoek de volgende URL met je browser:

http://127.0.0.1:5000/

Je zult de boeken zien die je aan de database hebt toegevoegd bij de eerste initialisatie.

Je hebt de boeken in je database weergegeven op de indexpagina. Nu moet je gebruikers toestaan om nieuwe boeken toe te voegen. Je zult een nieuwe route toevoegen voor het toevoegen van boeken in de volgende stap.

Stap 5 — Nieuwe Boeken Toevoegen

In deze stap maak je een nieuwe route aan voor het toevoegen van nieuwe boeken en recensies aan de database.

Je voegt een pagina toe met een webformulier waar gebruikers de titel van het boek, de auteur van het boek, het aantal pagina’s en de boekrecensie kunnen invoeren.

Laat de ontwikkelingsserver draaien en open een nieuw terminalvenster.

Eerst open je het bestand app.py:

  1. nano app.py

Om het webformulier te verwerken, moet je een paar dingen importeren uit het flask-pakket:

  • Het wereldwijde request-object om ingediende gegevens te kunnen raadplegen.
  • De functie url_for() om URL’s te genereren.
  • De functie redirect() om gebruikers door te verwijzen naar de startpagina nadat een boek aan de database is toegevoegd.

Voeg deze imports toe aan de eerste regel in het bestand:

flask_app/app.py

from flask import Flask, render_template, request, url_for, redirect

# ...

Voeg vervolgens de volgende route toe aan het einde van het bestand app.py:

flask_app/app.py

# ...


@app.route('/create/', methods=('GET', 'POST'))
def create():
    return render_template('create.html')

Sla het bestand op en sluit het.

In deze route geef je het tupel ('GET', 'POST') door aan de methods-parameter om zowel GET- als POST-verzoeken toe te staan. GET-verzoeken worden gebruikt om gegevens van de server op te halen. POST-verzoeken worden gebruikt om gegevens naar een specifieke route te verzenden. Standaard zijn alleen GET-verzoeken toegestaan. Wanneer de gebruiker voor het eerst de /create-route opvraagt met een GET-verzoek, wordt een sjabloonbestand genaamd create.html weergegeven. Je zult deze route later bewerken om POST-verzoeken te verwerken wanneer gebruikers het webformulier invullen en verzenden om nieuwe boeken toe te voegen.

Open het nieuwe sjabloonbestand create.html:

  1. nano templates/create.html

Voeg de volgende code toe:

flask_app/templates/create.html
{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Add a New Book {% endblock %}</h1>
    <form method="post">
        <p>
            <label for="title">Title</label>
            <input type="text" name="title"
                   placeholder="Book title">
            </input>
        </p>

        <p>
            <label for="author">Author</label>
            <input type="text" name="author"
                   placeholder="Book author">
            </input>
        </p>

        <p>
            <label for="pages_num">Number of pages</label>
            <input type="number" name="pages_num"
                   placeholder="Number of pages">
            </input>
        </p>
        <p>
        <label for="review">Review</label>
        <br>
        <textarea name="review"
                  placeholder="Review"
                  rows="15"
                  cols="60"
                  ></textarea>
        </p>
        <p>
            <button type="submit">Submit</button>
        </p>
    </form>
{% endblock %}

Sla het bestand op en sluit het.

Je breidt het basissjabloon uit, stelt een kop in als titel, en gebruikt een <form>-tag met het attribuut method ingesteld op post om aan te geven dat het formulier een POST-verzoek zal verzenden.

Je hebt een tekstveld met de naam title, dat je zult gebruiken om toegang te krijgen tot de titelgegevens in je /create-route.

Je hebt een tekstveld voor de auteur, een nummerveld voor het aantal pagina’s, en een tekstgebied voor de boekrecensie.

Als laatste heb je een Verzenden-knop aan het einde van het formulier.

Met de ontwikkelingsserver actief, gebruik je je browser om naar de /create-route te navigeren:

http://127.0.0.1:5000/create

Je zult een Voeg een nieuw boek toe-pagina zien met een invoerveld voor een boektitel, een voor de auteur, een voor het aantal pagina’s van het boek, een tekstgebied voor de boekrecensie, en een Verzenden-knop.

Als je het formulier invult en verzendt, door een POST-verzoek naar de server te sturen, gebeurt er niets omdat je geen POST-verzoeken hebt afgehandeld op de route /create.

Open app.py om het POST-verzoek dat de gebruiker indient af te handelen:

  1. nano app.py

Pas de /create-route als volgt aan:

flask_app/app.py

# ...

@app.route('/create/', methods=('GET', 'POST'))
def create():
    if request.method == 'POST':
        title = request.form['title']
        author = request.form['author']
        pages_num = int(request.form['pages_num'])
        review = request.form['review']

        conn = get_db_connection()
        cur = conn.cursor()
        cur.execute('INSERT INTO books (title, author, pages_num, review)'
                    'VALUES (%s, %s, %s, %s)',
                    (title, author, pages_num, review))
        conn.commit()
        cur.close()
        conn.close()
        return redirect(url_for('index'))

    return render_template('create.html')

Sla het bestand op en sluit het.

Je handelt POST-verzoeken af binnen de voorwaarde if request.method == 'POST'. Je haalt de titel, auteur, aantal pagina’s en de recensie die de gebruiker indient uit het request.form-object.

Je opent een database met behulp van de functie get_db_connection() en maakt een cursor. Vervolgens voer je een INSERT INTO SQL-opdracht uit om de door de gebruiker ingediende titel, auteur, aantal pagina’s en recensie in te voegen in de tabel books.

Je commit de transactie en sluit de cursor en verbinding.

Tenslotte stuur je de gebruiker door naar de indexpagina waar ze het nieuw toegevoegde boek onder de bestaande boeken kunnen zien.

Met de ontwikkelingsserver actief, gebruik je je browser om naar de route /create te navigeren:

http://127.0.0.1:5000/create

Vul het formulier in met wat gegevens en verstuur het.

Je wordt doorgestuurd naar de indexpagina waar je je nieuwe boekrecensie ziet.

Vervolgens voeg je een link toe naar de Create-pagina in de navigatiebalk. Open base.html:

  1. nano templates/base.html

Bewerk het bestand als volgt:

flask_app/templates/base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %} {% endblock %} - FlaskApp</title>
    <style>
        nav a {
            color: #d64161;
            font-size: 3em;
            margin-left: 50px;
            text-decoration: none;
        }

        .book {
            padding: 20px;
            margin: 10px;
            background-color: #f7f4f4;
        }

        .review {
                margin-left: 50px;
                font-size: 20px;
        }

    </style>
</head>
<body>
    <nav>
        <a href="{{ url_for('index') }}">FlaskApp</a>
        <a href="{{ url_for('create') }}">Create</a>
        <a href="#">About</a>
    </nav>
    <hr>
    <div class="content">
        {% block content %} {% endblock %}
    </div>
</body>
</html>

Sla het bestand op en sluit het.

Hier voeg je een nieuwe <a> link toe aan de navigatiebalk die naar de Create pagina verwijst.

Vernieuw je indexpagina en je zult de nieuwe link in de navigatiebalk zien.

Je hebt nu een pagina met een webformulier voor het toevoegen van nieuwe boekrecensies. Voor meer informatie over webformulieren, zie Hoe webformulieren te gebruiken in een Flask-applicatie. Voor een geavanceerdere en veiligere methode voor het beheren van webformulieren, zie Hoe webformulieren te gebruiken en te valideren met Flask-WTF.

Conclusie

Je hebt een kleine webapplicatie gebouwd voor boekrecensies die communiceert met een PostgreSQL-database. Je hebt basisfunctionaliteit voor databases in je Flask-applicatie, zoals het toevoegen van nieuwe gegevens aan de database, het ophalen van gegevens en het weergeven ervan op een pagina.

Als je meer wilt lezen over Flask, bekijk dan de andere tutorials in de Flask-serie.

Source:
https://www.digitalocean.com/community/tutorials/how-to-use-a-postgresql-database-in-a-flask-application