[PYTHON] Erstellen Sie mit Docker eine Umgebung aus NGINX + NGINX Unit + MySQL

Einführung von Docker

Zuvor habe ich eine Umgebung mit NGINX + NGINX Unit + Flask erstellt.

Führen Sie Python-Webanwendungen mit NGINX + NGINX Unit + Flask aus

Das letzte Mal habe ich es mit Vagrant und VirtualBox erstellt, aber dieses Mal werde ich es mit Docker erstellen. Verwenden Sie nach wie vor "NGINX" für den Webserver, "NGINX Unit" für den AP-Server und "Flask" für das Framework. Außerdem werden wir dieses Mal "MySQL" als Datenbank hinzufügen und eine Umgebung für "WEB <-> AP <-> DB" erstellen.

Das Bild ist in der folgenden Abbildung dargestellt. (Ursprünglich beginnt der Container auf dem Host, ist jedoch aus Gründen der Übersichtlichkeit getrennt.)

Wir werden es Schritt für Schritt erstellen. Wenn Sie also sehen möchten, was Sie getan haben, lesen Sie es bitte auf GitHub.

https://github.com/txkxyx/docker-web

Umgebung

Wir werden in der folgenden Umgebung bauen.

--Gastgeber - OS : macOS Catalina 10.15.3 - Docker : 19.03.5 --Container - Python : 3.7.3 - Flask : 1.1.1 - NGINX : 1.17.7 - NGINX Unit : 1.14.0 - MySQL : 8.0.18 - Flask SQLAclchemy : 2.4.1

Die Verzeichnisstruktur ist wie folgt.

./web
    |- db                   //Für DB
    |- nginx                //Für NGINX
    |- python               //NGINX-Einheit für Quelldateien
    |    |- src
    |- docker-compose.yml

Lass uns anfangen.

Dockerfilet- und Docker-Compose-Einstellungen

Hier ist eine kurze Zusammenfassung der Einstellungen, die in Dokerfile und Docker-Compose verwendet werden.

Dockerfile-Einstellungen

Weitere Informationen finden Sie in der offiziellen Dockerfile-Referenz.

https://docs.docker.com/engine/reference/builder/

Docker-Compose-Einstellungen

Weitere Informationen finden Sie in der offiziellen Referenz.

https://docs.docker.com/compose/compose-file/

Erstellen eines DB-Containers

Zuerst werden wir einen MySQL-Container erstellen. Das Bild sieht so aus.

Erstellen Sie "docker-compose.yml".

web/docker-compose.yml

version: "3"

services:
    db:
        image: mysql
        command: mysqld --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
        ports:
            - "33306:3306"
        expose:
            - "3306"
        environment:
            MYSQL_ROOT_PASSWORD: root
            MYSQL_USER: test
            MYSQL_PASSWORD: test
        volumes:
            - ./db/init:/docker-entrypoint-initdb.d
        container_name: app_db

Erstellen Sie ein "init" -Verzeichnis im "db" -Verzeichnis und erstellen Sie "createdatabase.sql", so wie Sie beim ersten Start des Containers eine Datenbank erstellen würden.

web/db/init/createdatabase.sql

CREATE DATABASE app;
USE app;

CREATE TABLE users(
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(255),
    email VARCHAR(255)
);

INSERT INTO users(name,email) VALUES('sample','[email protected]');
INSERT INTO users(name,email) VALUES('test','[email protected]');
INSERT INTO users(name,email) VALUES('app','[email protected]');

GRANT ALL ON app.* TO test;

Starten Sie mit den obigen Einstellungen den MySQL-Container mit Docker-Compose.

$ docker-compose up
$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                NAMES
bef9a864276c        mysql               "docker-entrypoint.s…"   4 minutes ago       Up 4 minutes        33060/tcp, 0.0.0.0:33306->3306/tcp   app_db

Wenn app_db im Ergebnis von docker ps angezeigt wird, wurde der Container gestartet. Überprüfen Sie im Container, ob die Datenbank erstellt wurde.

$ docker exec -it app_db bash
root@00000000000:/# mysql -u test -p
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| app                |
| information_schema |
+--------------------+
2 rows in set (0.00 sec)
mysql> use app;
mysql> select * from users;
+----+--------+-------------------+
| id | name   | email             |
+----+--------+-------------------+
|  1 | sample | [email protected] |
|  2 | test   | [email protected]     |
|  3 | app    | [email protected]       |
+----+--------+-------------------+
3 rows in set (0.01 sec)

Sie können sehen, dass eine Datenbank namens "App" erstellt wurde. Außerdem können Sie sehen, dass die Tabelle und die Daten für "createdatabase.sql" erstellt wurden. Das ist alles zum Erstellen von MySQL.

Erstellen eines AP-Containers

Erstellen Sie einen Container mit "NGINX Unit" als AP-Server, "Python3" als Ausführungsumgebung und "Flask" als Framework. Wir werden es unter Bezugnahme auf das offizielle Dokument von NGINX Unit erstellen. Das Bild sieht so aus.

Starten des NGINX Unit-Containers

Erstellen Sie zunächst die Umgebung von Python3 und Flask aus dem Image von NGINX Unit. Dies ist möglicherweise die kleinste Einheit der Entwicklungsumgebung. Fügen Sie "Dockerfile" zum "web / python" -Verzeichnis hinzu.

web/python/Dorckerfile

FROM nginx/unit:1.14.0-python3.7

WORKDIR /usr/src/app

COPY src .

RUN apt update && apt install -y python3-pip                               \
    && pip3 install --no-cache-dir -r ./requirements.txt                            \
    && rm -rf /var/lib/apt/lists/* 

CMD ["sleep","infinity"]

Verwenden Sie im Docker Hub nginx / unit site das NGINX Unit-Image für Python 3.7.

Erstellen Sie dann "require.txt" im Verzeichnis "web / python / src", damit Sie die Bibliotheken mit "pip" in großen Mengen installieren können.

web/python/src/requirements.txt

Flask == 1.1.1
flask-sqlalchemy == 2.4.1
PyMySQL == 0.9.3

Fügen Sie die Containereinstellungen der NGINX-Einheit zu "docker-compose.yml" hinzu.

docker-compose.yml

version: "3"

services:
    db:
        image: mysql
        ports:
            - "33306:3306"
        expose:
            - "3306"
        environment:
            MYSQL_ROOT_PASSWORD: root
            MYSQL_USER: test
            MYSQL_PASSWORD: test
        volumes:
            - ./db/init:/docker-entrypoint-initdb.d
        container_name: app_db
    #↓ ↓ Nachtrag
    ap:
        build: ./python
        ports:
            - "8080:8080"
        environment:
            TZ: "Asia/Tokyo"
        container_name: app_ap
        depends_on:
            - db

Die erstellte "Docker-Datei" befindet sich im Verzeichnis "web / python". Geben Sie daher den Speicherort mit build an. Der Server-Port sollte "8080" für den Host verfügbar machen. Stoppen Sie den laufenden Docker-Container, erstellen Sie ihn mit "Docker-Compose Build" und starten Sie den Container.

$ docker-compose down
$ docker-compose build --no-cache
$ docker-compose up
$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                NAMES
daf4ddc7c11a        web_ap              "sleep infinity"         41 seconds ago      Up 40 seconds       0.0.0.0:8080->8080/tcp               app_ap
565eb32e6a39        mysql               "docker-entrypoint.s…"   43 seconds ago      Up 41 seconds       33060/tcp, 0.0.0.0:33306->3306/tcp   app_db

Sie können sehen, dass der MySQL-Container app_db und der NGINX Unit-Container app_ap ausgeführt werden. Gehen Sie in den Container der NGINX-Einheit und überprüfen Sie, ob die Bibliothek "require.txt" installiert ist.

$ docker exec -it app_ap bash
root@00000000000:/# python3 -V
Python 3.7.3
root@00000000000:/# pip3 freeze
Flask==1.1.1
Flask-SQLAlchemy==2.4.1
PyMySQL==0.9.3

Zusätzlich zu den oben genannten Bibliotheken werden "SQL Alchemy" und "Jinja2" installiert. Damit ist der Start des NGINX Unit-Containers abgeschlossen. Als nächstes werden wir Flask implementieren.

Implementierung der Kolbenanwendung

Implementieren Sie die Flask-Anwendung. Die zu erstellenden Dateien und Verzeichnisse lauten wie folgt.

./web
    |- db
    |   |- init
    |       |- createdatabase.sql
    |- nginx  
    |- python
    |   |- src
    |   |   |- app.py ← hinzugefügt
    |   |   |- config.json ← hinzugefügt
    |   |   |- config.py ← hinzugefügt
    |   |   |- run.py ← hinzugefügt
    |   |   |- users.py ← hinzugefügt
    |   |   |- requirements.txt
    |   |   |-Vorlagen ← hinzugefügt
    |   |       |- list.html ← hinzugefügt
    |   |-Dockerfile ← Update
    |- docker-compose.yml

Jede Datei wird wie folgt implementiert.

config.py

Die erste ist config.py, die die Konfigurationsklasse wie das DB-Verbindungsziel implementiert. Das Host-Ziel wird durch den Containernamen "app_db" des DB-Containers angegeben.

web/python/src/config.py

class Config(object):
    '''
    Config Class
    '''
    # DB URL
    SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://test:test@app_db:3306/app?charset=utf8'

app.py

Als nächstes folgt app.py, mit dem die Flask-Anwendung gestartet wird. Verwenden Sie config.from_object (), um die Konfigurationsklasse der Anwendung aufzurufen, und verwenden Sie SQLAlchemy (), um die Flask-Anwendung zu initialisieren, damit SQLAchemy verwendet werden kann.

web/python/src/app.py

from config import Config
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

# Create Flask Application
application = Flask(__name__)

# Set Config Class
application.config.from_object(Config)

# Set DB
db = SQLAlchemy(application)

users.py

Erstellen Sie als Nächstes die Modellklasse für die Benutzertabelle. Erstellen Sie eine Users-Klasse, die von der db.Model-Klasse erbt.

web/python/src/users.py

from app import db

class Users(db.Model):
    '''
    Users Table Model
    '''
    __tablename__ = 'users'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(255))
    email = db.Column(db.String(255))

    def __init__(self,name,email):
        self.name = name
        self.email = email

run.py

Als nächstes folgt das Start- und Routing-Modul "run.py" der Flask-Anwendung. Da die Vorlagendatei für die Antwort verwendet wird, geben Sie die Vorlagendatei und das Objekt mit "render_template ()" an.

web/python/src/run.py

from app import application
from users import Users
from flask import render_template

@application.route('/list')
def index():
    users = Users.query.order_by(Users.id).all()
    return render_template('list.html', users=users)

if __name__ == '__main__':
    application.run(host='0.0.0.0', port='8080')

list.html

Erstellen Sie als Nächstes die Vorlagendatei "list.html". Das users-Objekt wird in render_template () übergeben, also implementieren Sie es mit der Template-Engine Jinja2.

web/python/src/templates/list.html

<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask Sample</title>
</head>
<body>
    <h1>Flask Sample</h1>
    <table border="1" style="border-collapse: collapse">
        <thead>
            <tr>
                <th >Id</th>
                <th >Name</th>
                <th >EMail</th>
            </tr>
        </thead>
        <tbody>
            {% for user in users %}
                <tr>
                    <td>{{user.id}}</td>
                    <td>{{user.name}}</td>
                    <td>{{user.email}}</td>
                </tr>
            {% endfor %}
        </tbody>
    </table>
</body>
</html>

Dockerfile

Update Dockerfile.

web/python/Dorckerfile

FROM nginx/unit:1.14.0-python3.7

WORKDIR /usr/src/app

COPY src .

RUN apt update && apt install -y python3-pip                               \
    && pip3 install --no-cache-dir -r ./requirements.txt                            \
    && rm -rf /var/lib/apt/lists/*
#↓ ↓ Löschen

config.json

Fügen Sie abschließend die NGINX Unit-Konfigurationsdatei config.json hinzu.

web/python/src/config.json

{
  "listeners": {
    "*:8080": {
      "pass": "applications/app"
    }
  },

  "applications": {
    "app": {
      "type": "python",
      "processes": 2,
      "path": "/usr/src/app/",
      "module": "run"
    }
  }
}

Das ist alles für die Implementierung.

Lassen Sie uns den Container erstellen und dann starten.

$ docker-compose down
$ docker-compose build --no-cache
$ docker-compose up
$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                NAMES
daf4ddc7c11a        web_ap              "sleep infinity"         41 seconds ago      Up 40 seconds       0.0.0.0:8080->8080/tcp               app_ap
565eb32e6a39        mysql               "docker-entrypoint.s…"   43 seconds ago      Up 41 seconds       33060/tcp, 0.0.0.0:33306->3306/tcp   app_db

Greifen Sie nach dem Starten des Containers "app_ap" auf den Container zu und legen Sie die Konfigurationsdatei für die NGINX-Einheit fest.

$ docker exec -it app_ap bash
root@00000000000:/# curl -X PUT --data-binary @config.json --unix-socket /var/run/control.unit.sock http://localhost/config
{
	"success": "Reconfiguration done."
}

Gehen Sie in Ihrem Browser zu "http: // localhost: 8080 / list" und der Bildschirm wird angezeigt.

Damit ist der Aufbau des AP-Containers abgeschlossen.

Erstellen Sie einen Webcontainer

Schließlich werden wir den NGINX-Container für den WEB-Server erstellen. Dadurch wird "NGINX <-> NGINX Unit <-> Flask <-> MySQL" konfiguriert.

Die hinzuzufügenden oder zu aktualisierenden Dateien lauten wie folgt.

./web
    |- db
    |   |- init
    |       |- createdatabase.sql
    |- nginx
    |   |-Dockerfile ← hinzugefügt
    |   |- index.html ← hinzugefügt
    |   |- nginx.conf ← hinzugefügt
    |- python
    |   |- src
    |   |   |- __init__.py
    |   |   |- app.py
    |   |   |- config.json
    |   |   |- config.py
    |   |   |- run.py
    |   |   |- users.py
    |   |   |- requirements.txt
    |   |   |- templates
    |   |       |- index.html
    |   |- Dockerfile
    |- docker-compose.yml ← Update

Erstellen Sie zunächst die oberste Seite "index.html".

web/nginx/index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Index</title>
</head>
<body>
    <h1>Index</h1>
    <a href="/list">List</a>
</body>
</html>

Als nächstes erstellen Sie eine Docker-Datei für NGINX.

FROM nginx

WORKDIR /var/www/html

COPY ./index.html ./

CMD ["nginx", "-g", "daemon off;","-c","/etc/nginx/nginx.conf"]

Erstellen Sie als Nächstes eine NGINX-Konfigurationsdatei. Ändern Sie in der im vorherigen Artikel vorgestellten Konfigurationsdatei den Host des AP-Servers für Docker.

nginx.conf

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                  '$status $body_bytes_sent "$http_referer" '
                  '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;
    server_tokens off;

    keepalive_timeout  65;

    #gzip  on;

    upstream unit-python {
        server app_ap:8080; # container_Angegeben durch den Namen
    }
    server {
        listen 80;
        server_name localhost;

        #Top-Seite anzeigen
        location  / {
            root /var/www/html;
        }

        # /Listen Sie die Routen zum AP-Container auf
        location  /list {
            proxy_pass http://unit-python;
            proxy_set_header Host $host;
        }
    }
}

Zum Schluss aktualisieren Sie Docker-Compose.

docker-compose.yml

version: "3"

services:
    db:
        image: mysql
        ports:
            - "33306:3306"
        expose:
            - "3306"
        environment:
            MYSQL_ROOT_PASSWORD: root
            MYSQL_USER: test
            MYSQL_PASSWORD: test
        volumes:
            - ./db/init:/docker-entrypoint-initdb.d
        container_name: app_db

    ap:
        build:
            context: ./python
            args:
                project_directory: "/src/"
        #↓ ↓ aktualisieren
        expose:
            - "8080"
        volumes:
            - "./python/src:/projects"
        environment:
            TZ: "Asia/Tokyo"
        container_name: app_ap
        depends_on:
            - db
    #↓ ↓ hinzugefügt
    web:
        build: ./nginx
        volumes:
            - ./nginx/nginx.conf:/etc/nginx/nginx.conf
        ports:
            - "80:80"
        environment:
            TZ: "Asia/Tokyo"
        container_name: "app_web"
        depends_on:
            - ap

Lassen Sie uns den Container erstellen und dann starten.

$ docker-compose down
$ docker-compose build --no-cache
$ docker-compose up
$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                NAMES
5b0f06b89db4        web_web             "nginx -g 'daemon of…"   2 minutes ago       Up 23 seconds       0.0.0.0:80->80/tcp                   app_web
625f3c025a82        web_ap              "/usr/local/bin/dock…"   2 minutes ago       Up 2 minutes        8080/tcp                             app_ap
fe5bf54411a2        mysql               "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes        33060/tcp, 0.0.0.0:33306->3306/tcp   app_db

Greifen Sie nach dem Starten des app_ap-Containers auf den Container zu und legen Sie die Konfigurationsdatei für die NGINX-Einheit fest.

$ docker exec -it app_ap bash
root@00000000000:/# curl -X PUT --data-binary @config.json --unix-socket /var/run/control.unit.sock http://localhost/config
{
	"success": "Reconfiguration done."
}

Wenn Sie mit einem Browser auf "http: // localhost: 80" zugreifen, wird die oberste Seite "index.html" angezeigt. (Nicht verfügbar über Port 8080)

Wenn Sie auf die verknüpfte "Liste" klicken, wird die Liste "Flasche.html" der Flaschenanwendung angezeigt.

Dies ist das Ende der NGINX-Konstruktion.

Zusammenfassung

Ich konnte mit Docker eine Umgebung von NGINX + NGINX Unit + MySQL erstellen. Sie müssen lediglich die Anwendung erstellen.