[PYTHON] Flask-Erstellen Sie einen Webdienst mit SQLAlchemy + PostgreSQL

Flask-Erstellen Sie einen Webdienst mit SQLAlchemy + PostgreSQL

Einführung

Ich werde es anhand einer Beispielanwendung (Feedback) vorstellen.

`Dies ist ein Artikel über die Mac-Umgebung, aber die Vorgehensweise ist für die Windows-Umgebung dieselbe. Bitte lesen und probieren Sie den umweltabhängigen Teil. ``

Zweck

Nachdem Sie diesen Artikel bis zum Ende gelesen haben, können Sie:

Ausführungsumgebung

Quellcode

Ich denke, dass Sie Ihr Verständnis vertiefen können, indem Sie den Implementierungsinhalten und dem Quellcode tatsächlich folgen. Bitte benutzen Sie es auf jeden Fall.

GitHub

Zum Thema passende Artikel

• RESTful-Webdienst mit Flask erstellen

0. Konfiguration der Entwicklungsumgebung

tree.sh

/
├── app
│   ├── __init__.py
│   ├── config.py
│   ├── feedback
│   │   ├── __init__.py
│   │   ├── common/
│   │   ├── models
│   │   │   ├── __init__.py
│   │   │   └── feedback.py
│   │   ├── static/
│   │   ├── templates/
│   │   └── views/
│   ├── run.py
│   └── tests/
└── instance
     ├── postgresql.py
     ├── sqlite3.py
     └── config.py

1. Flask-Entwicklung von SQL Alchemy

Paketinstallation

1. Installieren Sie das Paket.

   ~$ pip install Flask-Migrate
   ~$ pip install Flask-SQLAlchemy
   ~$ pip install Flask
   ~$ pip install psycopg2
   

2. Wenn bei der Installation von psycopg2 eine Fehlermeldung angezeigt wird, geben Sie die Umgebungsvariable an und führen Sie den Befehl aus (macOS + venv-Umgebung).

   ~$ xcode-select --install
   ~$ env LDFLAGS="-I/usr/local/opt/openssl/include -L/usr/local/opt/openssl/lib" pip install psycopg2
   

SQL Alchemy-Einstellungen

1. Legen Sie die Konfiguration der Entwicklungsumgebung fest.

   """instance/config.py
   """
   
   from instance.postgresql import SQLALCHEMY_DATABASE_URI as DATABASE_URI
   
   DEBUG = True
   # SECRET_KEY is generated by os.urandom(24).
   SECRET_KEY = '\xf7\xf4\x9bb\xd7\xa8\xdb\xee\x9f\xe3\x98SR\xda\xb0@\xb7\x12\xa4uB\xda\xa3\x1b'
   STRIPE_API_KEY = ''
   
   SQLALCHEMY_DATABASE_URI = DATABASE_URI
   SQLALCHEMY_TRACK_MODIFICATIONS = True
   SQLALCHEMY_ECHO = True
   

2. Richten Sie PostgreSQL ein.

   """instance/postgresql.py
   """
   
   SQLALCHEMY_DATABASE_URI = 'postgresql+psycopg2://{user}:{password}@{host}/{name}'.format(**{
       'user': 'nsuhara',
       'password': 'nsuhara',
       'host': '127.0.0.1',
       'name': 'db.postgresql'
   })
   

3. Richten Sie SQLite3 (Bonus) ein.

   """instance/sqlite3.py
   """
   
   import os
   
   SQLALCHEMY_DATABASE_URI = 'sqlite:///{host}/{name}'.format(**{
       'host': os.path.dirname(os.path.abspath(__file__)),
       'name': 'db.sqlite3'
   })
   

Modell erstellen

1. Erstellen Sie eine Instanz von SQLAlchemy.

   """app/feedback/models/__init__.py
   """
   
   from flask_sqlalchemy import SQLAlchemy
   
   db = SQLAlchemy()
   
   
   def init():
       """init
       """
       db.create_all()
   

2. Erstellen Sie ein Modell, indem Sie die SQLAlchemy-Klasse (db.Model) erben.

   """app/feedback/models/feedback.py
   """
   
   from datetime import datetime
   
   from feedback.models import db
   
   
   class Feedback(db.Model):
       """Feedback
       """
       __tablename__ = 'feedback'
   
       id = db.Column(db.Integer, primary_key=True, autoincrement=True)
       service = db.Column(db.String(255), nullable=False)
       title = db.Column(db.String(255), nullable=False)
       detail = db.Column(db.String(255), nullable=False)
       created_date = db.Column(
           db.DateTime, nullable=False, default=datetime.utcnow)
   
       def __init__(self, service, title, detail):
           self.service = service
           self.title = title
           self.detail = detail
   
       def to_dict(self):
           """to_dict
           """
           return {
               'id': self.id,
               'service': self.service,
               'title': self.title,
               'detail': self.detail,
               'created_date': self.created_date
           }
   

2. PostgreSQL-Einstellungen

Dies ist ein Beispiel für die Ausführung von "Homebrew".

Servicebestätigung

1. Überprüfen Sie den Service.

   ~$ brew services list
   

   Name       Status  User    Plist
   postgresql started nsuhara /Users/nsuhara/Library/LaunchAgents/homebrew.mxcl.postgresql.plist
   

Service Start / Ende

1. Starten Sie den Dienst.

   ~$ brew services start postgresql
   

2. Beenden Sie den Dienst.

   ~$ brew services stop postgresql
   

Überprüfen Sie die Datenbank

1. Überprüfen Sie die Datenbank.

`Standardmäßig werden drei Datenbanken erstellt. Außerdem wird der Mac-Benutzername als Eigentümer festgelegt. ``

```procedure.sh
~$ psql -l
```

```result.sh
                            List of databases
    Name      |  Owner  | Encoding | Collate | Ctype |  Access privileges
--------------+---------+----------+---------+-------+---------------------
postgres      | nsuhara | UTF8     | C       | C     |
template0     | nsuhara | UTF8     | C       | C     | =c/nsuhara         +
              |         |          |         |       | nsuhara=CTc/nsuhara
template1     | nsuhara | UTF8     | C       | C     | =c/nsuhara         +
              |         |          |         |       | nsuhara=CTc/nsuhara
```

Datenbankverbindung / -trennung

1. Stellen Sie eine Verbindung zur Datenbank her.

   ~$ psql -h "<host_name>" -p <port_number> -U "<role_name>" -d "<database_name>"
   

   ~$ psql -h "127.0.0.1" -p 5432 -U "nsuhara" -d "postgres"
   

2. Trennen Sie die Datenbank.

   postgresql=# \q
   

Erstellen einer Rolle (Benutzer)

1. Stellen Sie eine Verbindung zur Datenbank her.

2. Bestätigen Sie die Rolle (Benutzer).

   postgresql=# \du
   

                                   List of roles
   Role name |                         Attributes                         | Member of
   ----------+------------------------------------------------------------+-----------
   nsuhara   | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
   

3. Erstellen Sie eine Rolle (Benutzer).

   postgresql=# CREATE ROLE "<role_name>" LOGIN PASSWORD "password";
   

   postgresql=# CREATE ROLE "nsuhara" LOGIN PASSWORD "nsuhara";
   

4. Löschen Sie die Rolle (Benutzer).

   postgresql=# DROP ROLE "<role_name>";
   

   postgresql=# DROP ROLE "nsuhara";
   

Datenbank erstellen

1. Stellen Sie eine Verbindung zur Datenbank her.

2. Überprüfen Sie die Datenbank.

   postgresql=# \l
   

                           List of databases
       Name      |  Owner  | Encoding | Collate | Ctype |  Access privileges
   --------------+---------+----------+---------+-------+---------------------
   db.postgresql | nsuhara | UTF8     | C       | C     |
   postgres      | nsuhara | UTF8     | C       | C     |
   template0     | nsuhara | UTF8     | C       | C     | =c/nsuhara         +
                 |         |          |         |       | nsuhara=CTc/nsuhara
   template1     | nsuhara | UTF8     | C       | C     | =c/nsuhara         +
                 |         |          |         |       | nsuhara=CTc/nsuhara
   

3. Erstellen Sie eine Datenbank.

   postgresql=# CREATE DATABASE "<database_name>" OWNER "<role_ name>";
   

   postgresql=# CREATE DATABASE "db.postgresql" OWNER "nsuhara";
   

4. Löschen Sie die Datenbank.

   postgresql=# DROP DATABASE "<database_name>";
   

   postgresql=# DROP DATABASE "db.postgresql";
   

Datenbankmigration

1. Legen Sie die Umgebungsvariablen für den Kolben fest.

2. Migrieren Sie die Datenbank.

   ~$ flask db init
   ~$ flask db migrate
   ~$ flask db upgrade
   

Aufzeichnung löschen

1. Stellen Sie eine Verbindung zur Datenbank her.

2. Löschen Sie den Datensatz.

   postgresql=# delete from <table_name>;
   

3. Initialisieren Sie die automatische Nummerierung.

   postgresql=# select setval ('<table_name>_id_seq', 1, false);