Ça fait des années, machines virtuelles (MV) ils étaient l'outil principal pour héberger une application, car il encapsule le code et les fichiers de configuration ainsi que les dépendances nécessaires pour exécuter une application. Fournit les mêmes fonctionnalités qu'un système physique.
Pour exécuter plusieurs applications, nous devons démarrer plusieurs machines virtuelles et gérer un ensemble de machines virtuelles, nous avons besoin d'un hyperviseur.
La source: Infrastructure de partage d'applications
Passer des machines virtuelles aux conteneurs
La limitation de ce mécanisme (Machines virtuelles) c'est qu'il n'est pas efficace, puisque l'exécution de plusieurs applications répliquera vos propres systèmes d'exploitation, qui consomme beaucoup de ressources et, à mesure que les applications en cours d'exécution augmentent, nous avons besoin de plus d'espace pour allouer des ressources.
Un autre inconvénient est, supposons que nous devons partager notre application avec d'autres, et quand ils essaient d'exécuter l'application la plupart du temps, elle ne s'exécute pas en raison de problèmes de dépendance et pour cela, nous n'avons qu'à dire que "Fonctionne sur mon ordinateur portable / système". Ensuite, pour que d'autres exécutent les applications, doit configurer le même environnement dans lequel il s'est exécuté du côté hôte, ce qui signifie beaucoup de configuration manuelle et d'installation de composants.
La solution à ces limitations est une technologie appelée Conteneurs.
La création de modèles d'apprentissage automatique dans Jupyter Notebooks n'est la solution finale pour aucun POC / projet, nous devons le mettre en production pour résoudre les problèmes de la vie réelle en temps réel.
Ensuite, la première étape consiste à emballer / empaqueter notre application afin que nous puissions exécuter notre application sur n'importe quelle plate-forme cloud pour tirer parti des services gérés, de l'autoscaling et de la fiabilité, et beaucoup plus.
Pour packager notre application, nous avons besoin d'outils comme Docker. Alors commençons à travailler sur des outils géniaux et voyons la magie..
Conteneurs
Un conteneur est une unité logicielle standard qui conditionne le code et toutes ses dépendances afin que l'application s'exécute rapidement et de manière fiable d'un environnement informatique à un autre..
À présent, plusieurs machines virtuelles sont remplacées par plusieurs conteneurs s'exécutant sur un seul système d'exploitation hôte. Les applications exécutées dans des conteneurs sont complètement isolées et ont accès au système de fichiers, ressources et packages du système d'exploitation. Pour créer et exécuter des conteneurs, nous avons besoin d'outils de gestion de conteneurs, Quoi Arrimage.
La source: Applications qui partagent le système d'exploitation
Arrimage
Docker est un outil de gestion de conteneurs qui conditionne le code de l'application, configuration et dépendances dans une image portable qui peut être partagée et exécutée sur n'importe quelle plate-forme ou système. Con Docker, nous pouvons contenir plusieurs applications et les exécuter sur la même machine / système, car ils partageront tous les mêmes services du noyau du système d'exploitation, utilisent moins de ressources que les machines virtuelles (MV).
Une image de conteneur Docker est un progiciel léger, autonome et exécutable qui comprend tout ce dont vous avez besoin pour exécuter une application: code, temps d'exécution, Outils système, bibliothèques et paramètres système.
Les images de conteneurs sont converties en conteneurs au moment de l'exécution et, pour conteneurs Docker, les images deviennent des conteneurs lorsqu'elles sont exécutées sur Docker Engine.
Moteur le Docker
Docker Engine est l'environnement d'exécution du conteneur qui s'exécute sur divers systèmes d'exploitation Linux (CentOS, Debian, Feutre, Oracle Linux, RHEL, SUSE et Ubuntu) y Serveur Windows.
Docker Engine permet aux applications conteneurisées de s'exécuter n'importe où de manière cohérente sur n'importe quelle infrastructure, résoudre le “l'enfer de la dépendance” pour les développeurs et les équipes d'exploitation, et en éliminant le “Cela fonctionne sur mon ordinateur portable!!” problème.
Les conteneurs Docker qui s'exécutent sur le moteur Docker sont:
- Standard: Docker a créé la norme de l'industrie pour les conteneurs, afin qu'ils puissent être portables n'importe où.
- Léger: Les conteneurs partagent le noyau du système d'exploitation de la machine et, donc, ne nécessitent pas de système d'exploitation par application, résultant en une plus grande efficacité du serveur et des coûts de serveur et de licence inférieurs.
- Assurance: Les applications sont plus sécurisées dans les conteneurs et Docker fournit les capacités d'isolation par défaut les plus puissantes du secteur.
Installation des dockers
Docker est une plateforme ouverte de développement, envoyer et exécuter des applications. Docker nous permet de séparer nos applications de notre infrastructure afin que nous puissions livrer des logiciels rapidement.
Nous pouvons télécharger et installer Docker sur plusieurs plateformes. Découvrez le Docker officiel page pour installer Docker selon le système d'exploitation de votre système local.
Une fois Docker installé, Vous pouvez vérifier que l'installation a réussi en exécutant le débardeur commande dans le terminal / symbole du système.
La sortie sera similaire à la suivante, si vous obtenez une erreur d'autorisation, essayez de l'exécuter en mode utilisateur root (sous Linux, il est utilisé Sudo Docker).
La source: Auteur
Dockerfile
Un fichier simple composé d'instructions pour créer une image Docker. Chaque instruction dans un fichier docker est une commande / opération, par exemple, quel système d'exploitation utiliser, quelles dépendances installer ou comment compiler le code, et beaucoup de ces instructions qui agissent comme une couche.
La meilleure partie est que toutes les couches sont mises en cache et si nous modifions certaines instructions dans le Dockerfile, pendant le processus de construction, le calque modifié sera simplement reconstruit.
Un exemple de Dockerfile ressemblera à ci-dessous
FROM ubuntu:18.04 WORKDIR /app COPY . /app RUNpip install -r requirements.txtEXPOSER 5000 CMD python app.py
Chaque instruction crée une couche:
- DE créer un calque à partir de l'image de base, ici nous avons utilisé ubuntu: 18.04 Image Docker
- WORKDIR spécifier le répertoire de travail
- COPIER ajouter des fichiers à partir du répertoire actuel de votre client Docker ou de votre système hôte, ici, nous ajoutons les fichiers du répertoire actuel au répertoire de l'application du conteneur
- COURIR spécifier quelles commandes exécuter à l'intérieur du conteneur, ici, exécutez la commande pip pour installer les dépendances à partir du fichier requirements.txt
- EXPOSER spécifier quel port exposer notre application, c'est ici 5000
- CMD spécifie quelle commande exécuter au démarrage du conteneur
Image Docker
Une fois qu'un fichier docker est créé, nous pouvons créer une image docker à partir de celui-ci. Docker Image fournit l'environnement d'exécution pour une application, qui comprend tout le code, les fichiers de configuration requis et les dépendances.
Une image Docker se compose de calques en lecture seule, dont chacun représente une instruction Dockerfile. Les couches sont empilées et chacune est un delta des modifications de la couche précédente.
Nous pouvons créer une image docker avec un fichier docker en utilisant le construction de docker commander.
Une fois l'image docker créée, nous pouvons le tester en utilisant le Docker courir commander, qui créera un conteneur à l'aide d'une image docker et exécutera l'application.
Registre Docker
Une fois l'image docker créée et testée, nous pouvons le partager avec d'autres afin qu'ils puissent utiliser notre application. Pour ça, nous devons envoyer l'image docker au registre public d'images docker, como DockerHub, Registre de conteneurs Google (GCR) ou toute autre plateforme d'inscription.
Nous pouvons également envoyer nos images Docker à des dossiers privés pour restreindre l'accès aux images Docker.
Application d'apprentissage automatique
L'application d'apprentissage automatique consistera en un flux de travail complet à partir du traitement des entrées, l'ingénierie des fonctions à la génération de résultats. Nous allons voir une simple application d'analyse des sentiments, que nous allons conteneuriser à l'aide de Docker et envoyer cette application au DockerHub pour la rendre accessible aux autres.
Analyse des sentiments
Nous n'entrerons pas dans les détails sur les applications de machine learning, juste un aperçu, nous allons conteneuriser une application d'analyse des sentiments Twitter. Le code et les fichiers de données sont disponibles sur Github.
Vous pouvez cloner cette application ou elle peut contenir votre propre application, le processus sera le même.
Le dépôt git aura les fichiers suivants
- app.py: Application principale
- train.py: Script pour entraîner et enregistrer le modèle entraîné
- sentiment.tsv: fichier de données
- exigences.txt: contient les paquets / dépendances requises
- Dockerfile: pour créer l'image docker
- Dossier de modèles: contient notre page Web pour l'application
- dossier modèle: contient notre modèle entraîné
Voici comment exigences.txt on verra, nous pouvons également spécifier la version pour chaque bibliothèque que nous devons installer
numpy pandas scikit-apprendre ballon nltk expression régulière
Dans notre app.py, nous chargerons notre modèle entraîné et effectuerons le même prétraitement que lors de l'entraînement.
L'application Flask desservira deux points de terminaison, foyer, Oui prédire
@app.route('/')
def maison():
retourner render_template('home.html')
@app.route('/prédire',méthodes=['PUBLIER'])
def prédire():
si request.method == 'POST':
message = demande.formulaire['un message']
clean_test = remove_pattern(test,"@[w]*")
tokenized_clean_test = clean_test.split()
stem_tokenized_clean_test = [voix.tige(je) pour moi dans tokenized_clean_test]
message=" ".rejoindre(stem_tokenized_clean_test)
données = [un message]
données = cv.transformer(Les données)
my_prediction = clf.predict(Les données)
retourner render_template('résultat.html',prédiction = ma_prédiction)
Nous devons charger le modèle entraîné, le vectoriseur et le stemmer (utilisé dans la formation) et nous avons également configuré pour recevoir des requêtes sur le port 5000 dans localhost (0.0.0.0)
