Jusqu'à ce que l'API créée par Flask + MySQL soit convertie en Docker

c'est?

Je souhaite créer une API. Je veux le faire avec Flask + MySQL. Et je veux en faire Docker. Prenez note de cette procédure. Personnellement, je ne sais pas comment en faire Docker, je vais donc me concentrer sur cela.

Choses à faire

1. Créez une API simple avec Flask seul.
2. Convertissez 1 en Docker.
3. Préparez MySQL.
4. Activez l'intégration de Flask et MySQL à exécuter par docker-compose.

1. Créez une API simple avec Flask seul.

Tout d'abord, créez une API simple car tout va bien. Cette fois, j'ai décidé de faire une liste qui ne renvoie que les données qui remplissent les conditions de la liste des membres (provisoire).

À partir du fichier ci-dessous, créez une fonctionnalité où prefecture renvoie une liste d'adresses mail qui correspondent aux paramètres de la requête.

{personal_info.csv}

mail_address,sex,age,name,prefecture
[email protected],male,18,itirou,tokyo
[email protected],male,23,zirou,osaka
[email protected],male,31,saburou,tokyo
[email protected],female,29,itiko,tokyo
[email protected],mail,11,shirou,osaka
[email protected],female,42,fumiko,tokyo

Le code utilisant Flask est ici.

C'est super facile, lancez app.py, ajoutez? Pref = xxx à http: //127.0.0.1: 5000 /, et mail_address correspondant à pref = xxx sera renvoyé dans la liste.

Ensuite, créez cette API Docker.

2. Convertissez 1 en Docker.

«Making Docker» vise à créer un Dockerfile, une construction de docker pour créer une image Docker et d'exécuter app.py dans le conteneur avec docker run pour créer un état dans lequel les requêtes API sont lancées.

Un Dockerfile décrit l'opération consistant à «spécifier une image de base, décrire les paramètres du conteneur à créer et exécuter des commandes dans le conteneur» pour le conteneur que vous souhaitez créer.

2-1 Spécifiez l'image de base

Je veux juste pouvoir exécuter flask en python, je vais donc le baser sur l'image python.

2-2 Décrire les paramètres du conteneur

Pour exécuter le code flask, vous avez besoin des éléments suivants:

--Placez le code source local et les données dans un conteneur. --Installez les bibliothèques requises.

2-3 Exécutez la commande dans le conteneur.

Exécutez le fichier app.py.

Le Dockerfile créé avec ces 2-1 à 2-3 à l'esprit est le suivant.

# 2-1 Spécifiez l'image de base
FROM python:3.6  
# 2-2 Décrivez les paramètres du conteneur
ARG work_dir=/work  #Créer des variables à gérer dans Dockerfile
ADD pure_flask $work_dir/pure_flask  #le code/work/Copier(Notez que lors de la copie d'un répertoire, vous devez écrire le nom du répertoire sur le côté droit.)

WORKDIR $work_dir/pure_flask  #  cd work_image du répertoire

RUN pip install -r requirements.txt  # requirements.Installez les bibliothèques requises avec txt
# 2-3 Exécutez la commande dans le conteneur
CMD ["python", "/work/pure_flask/app.py"]   #Il n'y a fondamentalement qu'un seul CMD dans le Dockerfile.

requirements.txt est super facile à décrire uniquement flask.

{requirements.txt}

flask

Exécutez docker build -t flask: ver1 . dans le répertoire contenant le Dockerfile dans cet état. Dans la commande ci-dessus, vous devez créer une image à l'aide du Dockerfile du répertoire actuel.

Ensuite, exécutez docker run -it -d -p 5000: 5000 flask: ver1. -d pointe sur l'exécution en arrière-plan, -p 5000: 5000 points pour spécifier le port local 5000 et la redirection de port pour le port de conteneur 5000.

Dans cet état, si vous vérifiez avec un navigateur à localhost: 5000 sur la machine locale, vous pouvez vérifier le retour de l'API.

A propos, dans cet état, les "docker ps" et "docker images" sont les suivants. Si rien ne s'affiche dans docker ps, cela peut être une erreur, vous pouvez donc comprendre la raison en faisant docker logs [ID de conteneur] en utilisant l'ID de conteneur affiché par docker ps -a. ..

$ docker ps
> CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
> dc371c597cef        flask:ver1          "python /work/pure_f…"   9 minutes ago       Up 9 minutes        0.0.0.0:5000->5000/tcp   quizzical_margulis
$ docker images
> REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
> flask               ver1                b4cda0e56563        9 minutes ago       923MB
> python              3.6                 138869855e44        5 days ago          913MB

En toute sécurité, 1. J'ai pu confirmer la même opération sur Docker en créant une API simple avec Flask seul.

Ensuite, préparez-vous à utiliser MySQL.

3. Préparez MySQL.

MySQL est également préparé par Docker. Cette fois, nous utiliserons également Docker-compose.yaml en même temps.

Docker-compose.yaml est similaire à Dockerfile, mais pour décrire la liaison de plusieurs conteneurs. Puisqu'on suppose que la base de données sera connectée, je pense qu'il est naturel de l'écrire dans Docker-compose.

3-1 Spécifiez l'image de base

Je veux utiliser MySQL, donc je vais le baser sur l'image MySQL.

3-2 Décrire les paramètres du conteneur

Initialisez le fichier de configuration et la base de données MySQL.

3-3 Exécutez la commande dans le conteneur.

Démarrez un processus MySQL.

Le Dockerfile est ci-dessous.

# 3-1 Spécification de l'image de base
FROM mysql:5.7

# 3-2 Décrivez les paramètres du conteneur
COPY conf.d/mysql.cnf /etc/mysql/conf.d/mysql.cnf  #Ensemble de paramètres de code de caractère
COPY initdb.d/init.sql /docker-entrypoint-initdb.d/init.sql  #Ensemble de fichiers SQL pour l'initialisation

Le fichier de configuration et init.sql copiés dans le Dockerfile sont les suivants.

{mysql.cnf}

[mysqld]
character-set-server=utf8

[mysql]
default-character-set=utf8

[client]
default-character-set=utf8

{init.sql}

CREATE TABLE `personal_info` (
    mail_address VARCHAR(100) NOT NULL,
    sex VARCHAR(6) NOT NULL,
    age INT NOT NULL,
    name VARCHAR(50) NOT NULL,
    prefecture VARCHAR(50) NOT NULL,
    createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updatedAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    PRIMARY KEY (mail_address)
);

INSERT INTO `personal_info` (mail_address, sex, age, name, prefecture, createdAt, updatedAt)
VALUES
('[email protected]', 'male',   18, 'ichirou1' , 'tokyo', current_timestamp(), current_timestamp()),
('[email protected]', 'male',   23, 'zirou2', 'osaka', current_timestamp(), current_timestamp()),
('[email protected]', 'male',   31, 'saburou', 'tokyo', current_timestamp(), current_timestamp()),
('[email protected]', 'female', 29, 'itiko', 'tokyo', current_timestamp(), current_timestamp()),
('[email protected]', 'mail',   11, 'shirou', 'osaka', current_timestamp(), current_timestamp()),
('[email protected]', 'female', 42, 'fumiko', 'tokyo', current_timestamp(), current_timestamp());

docker-compose.yaml est ci-dessous.

version: '3'  # docker-compose.Description version de yaml
services:  
  db:  
    build: mysql  #Spécifiez le Dockerfile sous le répertoire mysql
    container_name: db_server  #Le nom du conteneur Docker
    ports:
      - '3306:3306'  #Spécification de la redirection de port
    environment:  #Définition des variables d'environnement
      MYSQL_ROOT_PASSWORD: pass  #Mot de passe de l'utilisateur root MySQL
      MYSQL_DATABASE: testdb     #Schéma MySQL
      TZ: Asia/Tokyo             #Spécifier le fuseau horaire
    volumes:  #Montage de volume pour la persistance des données MySQL
      - db-data/:/var/lib/mysql
    # 3-3 Exécutez la commande dans le conteneur
    command: mysqld  #Exécuter la commande mysqld
volumes:
  db-data:

Une fois que vous avez fait ce qui précède, démarrez le conteneur db avec docker-compose up -d. Après cela, connectez-vous avec docker exec -it [ID de conteneur] / bin / bash, entrez le mot de passe de mysql -u root -p pour vérifier la table, et si le contenu de init.sql est inclus, c'est OK. ..

[Remarques] conseils sur mysql

Si les données ne sont pas enregistrées dans le volume pour conserver les données MySQL, vérifiez le volume avec le volume docker ls sur l'hôte Docker, supprimez-le, puis docker-compose up -d.

Init.sql est copié de manière fixe dans /docker-entrypoint-initdb.d/.

Ensuite, connectez flask et MySQL.

4. Activez l'intégration de Flask et MySQL à exécuter par docker-compose.

Combinez les deux conteneurs Docker créés en 2 et 4. Tout ce que vous devez faire pour les combiner est:

• Mettez également flask dans docker-compose.yaml. --Autoriser une connexion de flask à MySQL (réseau).
• Permet une connexion de flask à MySQL (code).

Le flacon 4-1 est également placé dans docker-compose.yaml

Voici le conteneur flask ajouté à MySQL docker-compose.yaml.

version: '3'
services:
  api:
    build: python
    container_name: api_server
    ports:
      - "5000:5000"
    tty: yes
    environment:
      TZ: Asia/Tokyo
      FLASK_APP: app.py
    depends_on:  #Le serveur api est démarré après le démarrage du serveur db.
      - db
    networks:  #Spécification réseau commune pour la connexion de l'API et de la base de données
      - app_net
  db:
    build: mysql
    container_name: db_server
    ports:
      - '3306:3306'
    environment:
      MYSQL_ROOT_PASSWORD: pass
      MYSQL_DATABASE: testdb
      TZ: Asia/Tokyo
    volumes:
      - ./db-data:/var/lib/mysql
    command: mysqld
    networks:
      - app_net
volumes:
  db-data:
networks:
  app_net:
    driver: bridge

Dans la hiérarchie directement sous services, décrivez api comme étant la même hiérarchie que db.

4-2 Autoriser une connexion de flask à MySQL (réseau).

Lors du démarrage de deux conteneurs et de la connexion entre eux, il est nécessaire de gérer les deux conteneurs sur le même réseau. Ajoutez ce qui suit à chaque service dans 4-1 docker-compose.yaml.

networks:
      - app_net

Cela vous permet de spécifier le réseau utilisé par chaque conteneur. Cela signifie que les deux sont dans le même réseau. Ensuite, écrivez ce qui suit dans la hiérarchie de niveau supérieur de docker-compose.yaml.

networks:
  app_net:
    driver: bridge

Cela signifie créer un réseau docker et une spécification pour créer un pilote avec la spécification de pont. Maintenant que les conteneurs api et db sont sur le même réseau, il est possible de se connecter de api à db.

4-3 - Permet à un flacon de se connecter à MySQL (code).

Modification du code et du module côté flacon. Il semble y avoir de nombreuses façons de se connecter à MySQL à partir de python, mais cette fois, j'ai utilisé mysqlclient.

Installez mysqlclient avec pip install mysqlclient et connectez-vous avec le code suivant pour l'utiliser.

import MySQLdb

conn = MySQLdb.connect(user='root', passwd='pass', host='db_server', db='testdb')
cur = conn.cursor()
sql = "select * from personal_info;"
cur.execute(sql)
rows = cur.fetchall()

Les taples sont renvoyés sur ces lignes et des tapples de la longueur du nombre d'enregistrements peuvent être obtenus.

{Image des lignes.}

(
 (Valeur dans la première colonne du premier enregistrement,Valeur dans la deuxième colonne du premier enregistrement, ...), 
 (Valeur dans la première colonne du deuxième enregistrement,Valeur dans la deuxième colonne du deuxième enregistrement, ...),
 (Valeur dans la première colonne du troisième enregistrement,Valeur dans la deuxième colonne du troisième enregistrement, ...)
)

Une image qui le reçoit avec python, le stocke dans une liste et le renvoie avec json.

La source modifiée est ici. Veuillez vous y référer pour la structure des répertoires et l'emplacement du Dockerfile.

Après cela, puisque le nombre de modules que je souhaite gérer avec python a augmenté, ajoutez mysqlclient à requirements.txt.

C'est tout. Après avoir tout démarré avec docker-compose up -d, vous pouvez vérifier le résultat en entrant http: //0.0.0.0: 5000 /? Pref = osaka etc. localement.

c'est tout.