(Remarque) Remarques sur la création de l'environnement TensorFlow + Flask + Nginx avec Docker Compose

introduction

Pour mon mémorandum: sueur: Ceci est un mémo lors de la création d'un environnement de TensorFlow + Flask + Nginx avec Docker Compose. Juste Notes sur les applications utilisant TensorFlow Je faisais, mais j'ai décidé de le découper et de l'organiser. .. .. Après avoir effectué cette procédure, l'API Web utilisant TensorFlow devrait fonctionner: suer: Veuillez noter que c'est un article que j'ai fait pour moi-même, il peut donc être difficile à comprendre, les informations et la technologie peuvent être obsolètes: bow_tone1:

Matériel de référence

Je l'ai utilisé comme référence lors de la création de cet article: bow_tone1:

Environnement * Je pense que cela fonctionnera même si ce n'est pas la version suivante, mais veuillez noter qu'elle est ancienne: no_good_tone2: </ sup>

Version Ubuntu

$ cat /etc/os-release
NAME="Ubuntu"
VERSION="18.04.4 LTS (Bionic Beaver)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 18.04.4 LTS"
VERSION_ID="18.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=bionic
UBUNTU_CODENAME=bionic

Version Docker

$ docker version
Client: Docker Engine - Community
 Version:           19.03.8
 API version:       1.40
 Go version:        go1.12.17
 Git commit:        afacb8b7f0
 Built:             Wed Mar 11 01:25:46 2020
 OS/Arch:           linux/amd64
 Experimental:      false

Server: Docker Engine - Community
 Engine:
  Version:          19.03.8
  API version:      1.40 (minimum version 1.12)
  Go version:       go1.12.17
  Git commit:       afacb8b7f0
  Built:            Wed Mar 11 01:24:19 2020
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.2.13
  GitCommit:        7ad184331fa3e55e52b890ea95e65ba581ae3429
 runc:
  Version:          1.0.0-rc10
  GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
 docker-init:
  Version:          0.18.0
  GitCommit:        fec3683

Docker-Compose version

$ docker-compose version
docker-compose version 1.25.5, build unknown
docker-py version: 4.2.0
CPython version: 3.7.4
OpenSSL version: OpenSSL 1.1.1c  28 May 2019

* Pour une raison quelconque, build inconnu. J'ai abandonné parce que cela semblait prendre du temps: sanglot: </ sup>

Structure du répertoire

Je le fais correctement $ \ tiny {* Ne le fixez pas} $: no_good_tone1: Il y a beaucoup de fichiers inutiles, mais ils sont sur Github. Source

Structure du répertoire


dk_tensor_fw
├── app_tensor
│   ├── Dockerfile
│   ├── exeWhatMusic.py
│   ├── inputFile
│   │   └── ans_studyInput_fork.txt
│   ├── mkdbAndStudy.py
│   ├── requirements.txt
│   ├── studyModel
│   │   ├── genre-model.hdf5
│   │   ├── genre-tdidf.dic
│   │   ├── genre.pickle
│   ├── tfidfWithIni.py
│   └── webQueApiRunServer.py
├── docker-compose.yml
├── web_nginx
    ├── Dockerfile
    └── nginx.conf

Fichiers requis pour créer un environnement local avec docker-compose

docker-compose.yml


version: '3'
services:
###########Paramètres du serveur d'applications###########
  app_tensor:
    container_name: app_tensor
    #Politique de redémarrage du service
    restart: always
    #Répertoire contenant le fichier docker à construire
    build: ./app_tensor
    volumes:
      #Répertoire à monter
      - ./app_tensor:/dk_tensor_fw/app_tensor
    ports:
      #Port côté hôte: port côté conteneur
      - 7010:7010
    networks:
      - nginx_network
###########Paramètres du serveur d'applications###########

###########Paramètres du serveur Web###########
  web-nginx:
    container_name: web-nginx
    build: ./web_nginx
    volumes:
      #Répertoire à monter
      - ./web_nginx:/dk_tensor_fw/web_nginx
    ports:
      #Transfert de port du PC hôte 7020 au conteneur 7020
      - 7020:7020
    depends_on:
      #Spécifiez la dépendance. la toile-app avant de démarrer le serveur-Va démarrer le serveur
      - app_tensor
    networks:
      - nginx_network
###########Paramètres du serveur Web###########
networks:
  nginx_network:
    driver: bridge

(Référence) Comment vérifier les ports libres


#Vérifiez les ports libres (gratuits si rien n'est affiché)
netstat -an | grep 7010

Dockerfile ← Côté serveur Ap(Gunicorn)


FROM ubuntu:18.04

WORKDIR /dk_tensor_fw/app_tensor
COPY requirements.txt /dk_tensor_fw/app_tensor

RUN apt-get -y update \
    && apt-get -y upgrade \
    && apt-get install -y --no-install-recommends locales curl python3-distutils vim ca-certificates \
    && curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py \
    && python3 get-pip.py \
    && pip install -U pip \
    && localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8 \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* \
    && pip install -r requirements.txt --no-cache-dir

ENV LANG en_US.utf8

CMD ["gunicorn", "webQueApiRunServer:app", "-b", "0.0.0.0:7010"]

requirements.txt


Flask==1.1.0
gunicorn==19.9.0
Keras>=2.2.5
numpy==1.16.4
pandas==0.24.2
pillow>=6.2.0
python-dateutil==2.8.0
pytz==2019.1
PyYAML==5.1.1
requests==2.22.0
scikit-learn==0.21.2
sklearn==0.0
matplotlib==3.1.1
tensorboard>=1.14.0
tensorflow>=1.14.0
mecab-python3==0.996.2

Par analogie avec la source python suivante utilisant un modèle appris par machine, Le corps de l'API Web qui renvoie la réponse Json. Module d'analogie réelle (exeWhatMusic) Lit de l'extérieur: sweat_smile:

webQueApiRunServer.py


import flask
import os
import exeWhatMusic

#numéro de port
TM_PORT_NO = 7010

# initialize our Flask application and pre-trained model
app = flask.Flask(__name__)
app.config['JSON_AS_ASCII'] = False  # <--Évitez les caractères japonais brouillés

@app.route('/recommend/api/what-music/<how_music>', methods=['GET'])
def get_recom_music(how_music):
    recoMusicInfos = getRecoMusicMoji(how_music)
    return flask.jsonify({'recoMusicInfos': recoMusicInfos})

#Renvoie le nom du morceau recommandé
def getRecoMusicMoji(how_music):

    recMusicName, predict_val = exeWhatMusic.check_genre(how_music)

    #Création JSON
    recoMusicInfoJson = [
        {
            'id':1,
            'recoMusicMoji':recMusicName,
            'predict_val':predict_val,
            'how_music':how_music
        }
    ]
    return recoMusicInfoJson

if __name__ == "__main__":
    print(" * Flask starting server...")
    app.run(threaded=False, host="0.0.0.0", port=int(os.environ.get("PORT", TM_PORT_NO)))

Dockerfile ← Côté serveur Web(Nginx)


FROM nginx:latest

RUN rm /etc/nginx/conf.d/default.conf
COPY nginx.conf /etc/nginx/conf.d

nginx.conf


    upstream app_tensor_config {
        #Si vous spécifiez le nom de service du conteneur, le nom sera résolu
        server app_tensor:7010;
    }

    server {
        listen 7020;
        root /dk_tensor_fw/app_tensor/;
        server_name localhost;

        location / {
            try_files $uri @flask;
        }

        location @flask {
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_redirect off;

            proxy_pass http://app_tensor_config;
        }

        # redirect server error pages to the static page /50x.html
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/share/nginx/html;
        }

        #Les demandes de fichiers statiques sont acheminées de manière statique ← Cela n'est pas nécessaire car il n'est pas utilisé.
        location /static/ {
            alias /dk_tensor_fw/app_tensor/satic/;
        }
    }

Confirmation de l'environnement terminé

Commencez avec la construction et l'arrière-plan

$ docker-compose up -d --build

docker-compose Afficher les informations sur l'image

$ docker-compose images
Container          Repository           Tag       Image Id       Size  
-----------------------------------------------------------------------
app_tensor   dk_tensor_fw_app_tensor   latest   3b916ea797e0   2.104 GB
web-nginx    dk_tensor_fw_web-nginx    latest   175c2596bb8b   126.8 MB

Est-il mal fait? Il semble que la capacité soit assez grande: sueur: </ sup>

Liste des conteneurs

$ docker-compose ps
   Name                 Command               State               Ports             
------------------------------------------------------------------------------------
app_tensor   gunicorn webQueApiRunServe ...   Up      0.0.0.0:7010->7010/tcp        
web-nginx    nginx -g daemon off;             Up      0.0.0.0:7020->7020/tcp, 80/tcp

Se connecter au conteneur (côté serveur Ap)

$ docker-compose exec app_tensor /bin/bash
root@ba0ce565430c:/dk_tensor_fw/app_tensor#

Je l'ai mis dans un conteneur côté serveur Ap. .. ..

Vérifiez le contenu pour voir si TensorFlow ou Keras est inclus

J'en ai omis car l'affichage du résultat de sortie est long: sueur: </ sup>

root@ba0ce565430c:/dk_tensor_fw/app_tensor# pip3 list
Package                Version
---------------------- -----------
absl-py                0.9.0
Flask                  1.1.0
gunicorn               19.9.0
Keras                  2.3.1
Keras-Applications     1.0.8
Keras-Preprocessing    1.1.2
matplotlib             3.1.1
mecab-python3          0.996.2
numpy                  1.16.4
pandas                 0.24.2
Pillow                 7.1.2
pip                    20.1
python-dateutil        2.8.0
pytz                   2019.1
PyYAML                 5.1.1
requests               2.22.0
requests-oauthlib      1.3.0
rsa                    4.0
scikit-learn           0.21.2
six                    1.14.0
sklearn                0.0
tensorboard            2.2.1
tensorboard-plugin-wit 1.6.0.post3
tensorflow             2.2.0
tensorflow-estimator   2.2.0
(réduction)

Il semble que TensorFlow, Keras, etc. soient tous inclus. .. ..

Connectez-vous au conteneur côté serveur Web

$ docker-compose exec web-nginx /bin/bash
root@d6971e4dc05c:/# 

Je l'ai également mis dans le conteneur côté serveur Web.

Pour le moment, vérifiez si le serveur Web (Nginx) fonctionne.

root@d6971e4dc05c:/# /etc/init.d/nginx status
[ ok ] nginx is running.

Il semble que Nginx fonctionne également. Jusqu'à présent, j'ai confirmé l'environnement d'exécution. Si vous cliquez sur l'API WEB comme indiqué ci-dessous, vous devriez avoir un environnement d'exécution du côté de l'API WEB. .. ..

Web_Exemple d'exécution d'API


http://localhost:7020/recommend/api/what-music/Une chanson qui est triste et souhaite le bonheur de quelqu'un

Exemple d'exécution d'API Web

Peek 2020-05-16 14-30.gif Il existe divers outils, donc je pense que tout va bien, mais comme GIF Il sera retourné en JSON.

Autres commandes (note)

* Le matériel de référence est tel qu'il est. Veuillez consulter les documents de référence pour plus de détails: bow_tone1: </ sup>

Panne de service
$ docker-compose stop      
Début du service
$ docker-compose start
Quand vous voulez nettoyer l'environnement
#Arrêter et supprimer
#Réseau de conteneurs
docker-compose down

Image du réseau de conteneurs
docker-compose down --rmi all

#Volume du réseau de conteneurs
docker-compose down -v

Recommended Posts

(Remarque) Remarques sur la création de l'environnement TensorFlow + Flask + Nginx avec Docker Compose
(Remarque) Remarques sur la création d'un environnement Tensor Flow avec Docker Compose (un seul conteneur)
Journal de sortie vers la console avec Flask + Nginx sur Docker
Remarque sur la création de votre propre environnement Miniconda
Créer un environnement Python + uWSGI + Nginx avec Docker
Lancez l'application Flask avec Docker sur Heroku
Construire un environnement de NGINX + NGINX Unit + MySQL avec Docker
Notes sur Flask
Remarque: préparez l'environnement de CmdStanPy avec docker
Créer un environnement de Nginx + uWSGI + Python (Django) avec docker
Exécutez Flask sur CentOS avec python3.4, Gunicorn + Nginx.
Utilisation de Flask avec la configuration Nginx + gunicorn [Environnement local]
Construction d'environnement virtuel avec Docker + Flask (Python) + notebook Jupyter
Création d'un environnement TensorFlow qui utilise des GPU sous Windows 10
Remarques sur la création d'un environnement virtuel avec Anaconda Navigator
[Avec diagramme d'image] Nginx + gunicorn + Flask converti en Docker [Partie 2]
Créez un environnement de développement Django avec Docker! (Docker-compose / Django / postgreSQL / nginx)
De la construction de l'environnement au déploiement pour flask + Heroku avec Docker
[Avec diagramme d'image] Nginx + gunicorn + Flask converti en Docker [Partie 1]
Préparer l'environnement python3 avec Docker
[Tensorflow] Construction de l'environnement Tensorflow sous Windows 10
Essayez de créer Jupyter Hub avec Docker
Créer une application Rails avec Docker
Créez rapidement un environnement d'exécution d'application Web Python3.4 + Nginx + uWSGI + Flask en utilisant pyenv sur Ubuntu 12.04
Création d'un environnement d'apprentissage HPC à l'aide de Docker Compose (C, Python, Fortran)
Construction d'environnement Postgres avec Docker J'ai eu un peu de mal, alors notez
Création d'un environnement de développement avec Maven sur Google App Engine [Java]
Créer un environnement Kubernetes avec Ansible 2
Construire un environnement Python sur Mac
Essayez d'exécuter tensorflow sur Docker + anaconda
Remarques sur la gestion des packages avec conda
Construire un environnement Python sur Ubuntu
Créer un serveur Flask avec Docker
Construire un environnement Mysql + Python avec docker
Exécutez l'image Docker de TensorFlow sur Python3
Créer un environnement virtuel avec Python 3
Utilisez Tensorflow 2.1.0 avec Anaconda sur Windows 10!
[Linux] Construction de l'environnement Docker sur Redhat
environnement en ligne du serveur de code (5) Lancer le serveur de code sur Docker
Notes sur l'utilisation de rstrip avec python.
Créer un environnement Kubernetes avec Ansible 1
Reconstruisez l'environnement de développement de Django avec Docker! !! !! !!
Développement d'applications avec Docker + Python + Flask
Procédure de création d'un environnement Kube sur Amazon Linux2 (AWS) ~ (avec bonus)
Construisez un environnement Python + bouteille + MySQL avec Docker sur RaspberryPi3! [Construction facile]
Créez rapidement un environnement d'exécution d'application Web Python3.4 + Nginx + uWSGI + Flask en utilisant venv sur Ubuntu 14.04 LTS