Guide Kubernetes, Partie 1: Applications, microservices et conteneurs

À notre demande, Habr a créé le hub Kubernetes et nous sommes heureux d'y publier la première publication. Abonnez-vous!

Kubernetes est facile. Pourquoi les banques me paient-elles beaucoup d'argent pour travailler dans ce domaine, alors que n'importe qui peut maîtriser cette technologie en quelques heures seulement?



Si vous doutez que Kubernetes puisse être appris si rapidement, je vous suggère d'essayer de le faire vous-même. A savoir, après avoir maîtrisé ce matériel, vous pourrez exécuter l'application basée sur des microservices dans le cluster Kubernetes. Je peux le garantir, car c'est précisément par la méthodologie utilisée ici que je forme Kubernetes à travailler avec nos clients. Qu'est-ce qui distingue ce manuel des autres? En fait - beaucoup de choses. Ainsi, la plupart de ces documents commencent par une explication de choses simples - les concepts de Kubernetes et les fonctionnalités de l'équipe kubectl. Les auteurs de ces documents estiment que leur lecteur connaît le développement d'applications, les microservices et les conteneurs Docker. Nous irons dans l'autre sens. Voyons d'abord comment exécuter une application basée sur des microservices sur un ordinateur. Considérez ensuite l'assemblage d'images de conteneurs pour chaque microservice. Après cela, nous apprendrons à connaître Kubernetes et analyserons le déploiement d'une application basée sur des microservices dans un cluster géré par Kubernetes.

Une telle approche, avec une approche progressive de Kubernetes, donnera la profondeur de la compréhension qui arrive à une personne ordinaire afin de comprendre à quel point tout est organisé dans Kubernetes. Kubernetes est, bien sûr, une technologie simple, à condition que quiconque veut l'apprendre sache où et comment il est utilisé.

Maintenant, sans plus tarder, mettons-nous au travail et parlons de l'application avec laquelle nous allons travailler.

Application expérimentale

Notre application ne remplira qu'une seule fonction. Il accepte, en entrée, une phrase, puis, en utilisant les moyens d'analyse de texte, effectue une analyse des sentiments de cette phrase, en recevant une estimation de l'attitude émotionnelle de l'auteur de la phrase envers un certain objet.

Voici à quoi ressemble la fenêtre principale de cette application.


Application Web pour l'analyse du sentiment de texte

D'un point de vue technique, l'application se compose de trois microservices, chacun résolvant un certain ensemble de tâches:

• SA-Frontend est un serveur Web Nginx qui sert des fichiers statiques React.
• SA-WebApp est une application Web basée sur Java qui traite les demandes du front-end.
• SA-Logic est une application Python qui effectue une analyse de sentiment de texte.

Il est important de noter que les microservices n'existent pas isolément. Ils mettent en œuvre l'idée de "séparation des tâches", mais ils doivent cependant interagir les uns avec les autres.


Flux de données d'application

Dans le diagramme ci-dessus, vous pouvez voir les étapes numérotées du système, illustrant les flux de données dans l'application. Analysons-les:

1. Le navigateur demande le fichier index.html au serveur (qui, à son tour, télécharge le package d'application React).
2. L'utilisateur interagit avec l'application, ce qui provoque un appel à une application Web basée sur Spring.
3. L'application Web redirige la demande d'analyse de texte vers l'application Python.
4. L'application Python analyse la tonalité du texte et renvoie le résultat en réponse à la demande.
5. L'application Spring envoie une réponse à l'application React (et elle montre à son tour le résultat de l'analyse de texte à l'utilisateur).

Le code de toutes ces applications se trouve ici . Je vous recommande maintenant de copier ce référentiel pour vous-même, car il y a beaucoup d'expériences intéressantes devant nous.

Démarrage d'une application basée sur un microservice sur un ordinateur local

Pour que l'application fonctionne, nous devons exécuter les trois microservices. Commençons par les plus mignons d'entre eux - avec l'application frontale.

▍Configurer React pour le développement local

Pour exécuter l'application React, vous devez installer les plates-formes Node.js et NPM sur votre ordinateur. Après avoir installé tout cela, passez par le terminal dans le dossier du projet sa-frontend et exécutez la commande suivante:

 npm install 

Grâce à l'exécution de cette commande, les dépendances de l'application React, dont les entrées se trouvent dans le fichier package.json , seront chargées dans le dossier node_modules . Une fois les dépendances téléchargées dans le même dossier, exécutez la commande suivante:

 npm start 

C’est tout. Maintenant que l'application React est en cours d'exécution, vous pouvez y accéder en accédant à l'adresse localhost:3000 dans le navigateur. Vous pouvez changer quelque chose dans son code. Vous verrez immédiatement l'effet de ces changements dans le navigateur. Ceci est possible grâce au remplacement dit "à chaud" des modules. Grâce à cela, le développement frontal devient une tâche simple et agréable.

▍Préparation d'une application React de sortie en production

Pour une utilisation réelle de l'application React, nous devons la convertir en un ensemble de fichiers statiques et les remettre aux clients utilisant un serveur Web.

Pour créer l'application React, à nouveau, à l'aide du terminal, accédez au dossier sa-frontend et exécutez la commande suivante:

 npm run build 

Cela créera un répertoire de build dans le dossier du projet. Il contiendra tous les fichiers statiques nécessaires au fonctionnement de l'application React.

▍Service de fichiers statiques à l'aide des outils Nginx

Vous devez d'abord installer et exécuter le serveur Web Nginx. Ici, vous pouvez le télécharger et trouver les instructions d'installation et de démarrage. Ensuite, vous devez copier le contenu du dossier sa-frontend/build dossier [your_nginx_installation_dir]/html .

Avec cette approche, le fichier index.html généré lors de la construction de l'application React sera disponible dans [your_nginx_installation_dir]/html/index.html . Il s'agit du fichier que, par défaut, le serveur Nginx émet lors de son accès. Le serveur est configuré pour écouter sur le port 80 , mais vous pouvez le configurer selon vos besoins en modifiant le fichier [your_nginx_installation_dir]/conf/nginx.conf .

Ouvrez maintenant votre navigateur et accédez à localhost:80 . Vous verrez la page d'application React.


Application React servie par le serveur Nginx

Si vous tapez quelque chose dans le champ Type your sentence maintenant et cliquez sur le bouton Send , rien ne se passera. Mais, si vous regardez la console, vous pouvez y voir des messages d'erreur. Afin de comprendre exactement où ces erreurs se produisent, analysons le code de l'application.

▍Analyse du code de l'application frontale

App.js regardé le code du fichier App.js , nous pouvons voir que cliquer sur le bouton Send appelle la méthode analyzeSentence() . Le code de cette méthode est donné ci-dessous. Dans le même temps, faites attention au fait que pour chaque ligne pour laquelle il y a un commentaire du formulaire # , il y a une explication donnée sous le code. De la même manière, nous analyserons d'autres morceaux de code.

 analyzeSentence() {   fetch('http://localhost:8080/sentiment', {  // #1       method: 'POST',       headers: {           'Content-Type': 'application/json'       },       body: JSON.stringify({                      sentence: this.textField.getValue()})// #2   })       .then(response => response.json())       .then(data => this.setState(data));  // #3 } 

1. URL à laquelle la requête POST est exécutée. Il est entendu que cette adresse contient une application qui attend de telles demandes.

2. L'organisme de demande envoyé à la demande. Voici un exemple de corps de demande:

 {   sentence: "I like yogobella!" } 

3. Dès réception d'une réponse à la demande, l'état du composant est mis à jour. Cela provoque le rendu du composant. Si nous recevons des données (c'est-à-dire un objet JSON contenant les données entrées et le score de texte calculé), nous afficherons la composante Polarity , car les conditions correspondantes seront remplies. Voici comment nous décrivons le composant:

 const polarityComponent = this.state.polarity !== undefined ?   <Polarity sentence={this.state.sentence}             polarity={this.state.polarity}/> :   null; 

Le code semble fonctionner assez bien. Qu'est-ce qui ne va pas ici, après tout? Si vous supposez qu'à l'adresse où l'application essaie d'envoyer une demande POST, il n'y a jusqu'à présent rien qui puisse accepter et traiter cette demande, alors vous aurez absolument raison. À savoir, pour traiter les demandes arrivant à l'adresse http://localhost:8080/sentiment , nous devons exécuter une application Web basée sur Spring.


Nous avons besoin d'une application Spring qui peut accepter une demande POST.

▍Configurez une application Web basée sur Spring

Pour déployer l'application Spring, vous aurez besoin de JDK8 et Maven et de variables d'environnement correctement configurées. Après avoir installé tout cela, vous pouvez continuer à travailler sur notre projet.

▍Emballage de l'application dans un fichier jar

Accédez, à l'aide du terminal, au dossier sa-webapp et entrez la commande suivante:

 mvn install 

Après avoir exécuté cette commande, le répertoire target sera créé dans le dossier sa-webapp . Il y aura une application Java emballée dans un fichier jar représenté par sentiment-analysis-web-0.0.1-SNAPSHOT.jar .

▍Démarrez l'application Java

Accédez au dossier target et lancez l'application avec la commande suivante:

 java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar 

Une erreur se produira lors de l'exécution de cette commande. Afin de commencer à le réparer, nous pouvons analyser les informations d'exception dans les données de trace de pile:

 Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}" 

Pour nous, la chose la plus importante ici est la mention de l'impossibilité de déterminer la signification de sa.logic.api.url . Analysons le code dans lequel l'erreur se produit.

▍ Analyse de code d'application Java

Voici l'extrait de code où l'erreur se produit.

 @CrossOrigin(origins = "*") @RestController public class SentimentController {   @Value("${sa.logic.api.url}")    // #1   private String saLogicApiUrl;   @PostMapping("/sentiment")   public SentimentDto sentimentAnalysis(       @RequestBody SentenceDto sentenceDto)   {       RestTemplate restTemplate = new RestTemplate();       return restTemplate.postForEntity(               saLogicApiUrl + "/analyse/sentiment",    // #2               sentenceDto, SentimentDto.class)               .getBody();   } } 

1. S entimentController a un champ saLogicApiUrl . Sa valeur est définie par la propriété sa.logic.api.url .
2. La chaîne saLogicApiUrl concaténée avec la valeur /analyse/sentiment . Ensemble, ils forment une adresse pour accéder à un microservice qui effectue une analyse de texte.

▍Définir la valeur de la propriété

Dans Spring, la source standard des valeurs de propriété est le fichier application.properties , qui se trouve dans sa-webapp/src/main/resources . Mais son utilisation n'est pas le seul moyen de définir des valeurs de propriété. Vous pouvez le faire avec une commande comme la suivante:

 java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL 

La valeur de cette propriété doit pointer vers l'adresse de notre application Python.

En le configurant, nous indiquons à l'application Web Spring où elle doit aller pour exécuter les demandes d'analyse de texte.

Afin de ne pas compliquer nos vies, nous décidons que l'application Python sera disponible sur localhost:5000 et essayons de ne pas l'oublier. Par conséquent, la commande pour lancer l'application Spring ressemblera à ceci:

 java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000 

Notre système n'a pas d'application Python

Il ne nous reste plus qu'à démarrer l'application Python et le système fonctionnera comme prévu.

▍Configuration d'une application Python

Pour exécuter une application Python, vous devez avoir installé Python 3 et Pip, et vous devez définir correctement les variables d'environnement appropriées.

▍Installation de dépendances

Accédez au dossier du projet sa-logic/sa et exécutez les commandes suivantes:

 python -m pip install -r requirements.txt python -m textblob.download_corpora 

▍Démarrez l'application

Après avoir installé les dépendances, nous sommes prêts à lancer l'application:

 python sentiment_analysis.py 

Après avoir exécuté cette commande, nous serons informés des éléments suivants:

 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit) 

Cela signifie que l'application est en cours d'exécution et attend les demandes sur localhost:5000/

▍ Recherche de code

Considérez le code d'application Python pour comprendre comment il répond aux demandes:

 from textblob import TextBlob from flask import Flask, request, jsonify app = Flask(__name__)                                   #1 @app.route("/analyse/sentiment", methods=['POST'])      #2 def analyse_sentiment():   sentence = request.get_json()['sentence']           #3   polarity = TextBlob(sentence).sentences[0].polarity #4   return jsonify(                                     #5       sentence=sentence,       polarity=polarity   ) if __name__ == '__main__':   app.run(host='0.0.0.0', port=5000)                #6 

1. Initialisation d'un objet Flask .
2. Définition de l'adresse pour lui exécuter des requêtes POST.
3. Récupération de la propriété de sentence du corps de la requête.
4. Initialisation de l'objet TextBlob anonyme et obtention de la valeur de polarity pour la première phrase dans le corps de la requête (dans notre cas, c'est la seule phrase passée pour analyse).
5. Le retour de la réponse, dans le corps duquel se trouve le texte de la proposition et l'indice de polarity calculé pour celle-ci.
6. Lancement de l'application Flask, qui sera disponible à l'adresse 0.0.0.0:5000 (vous pouvez également y accéder en utilisant un design du formulaire localhost:5000 ).

Maintenant, les microservices qui composent l'application sont en cours d'exécution. Ils sont configurés pour interagir les uns avec les autres. Voici à quoi ressemble le diagramme d'application à ce stade du travail.


Tous les microservices qui composent l'application sont portés à un état sain.

Maintenant, avant de continuer, ouvrez l'application React dans un navigateur et essayez d'analyser certaines suggestions en l'utilisant. Si tout est fait correctement, après avoir cliqué sur le bouton Send , vous verrez les résultats de l'analyse sous la zone de texte.

Dans la section suivante, nous expliquerons comment exécuter nos microservices dans des conteneurs Docker. Cela est nécessaire pour préparer le lancement de l'application dans le cluster Kubernetes.

Conteneurs Docker

Kubernetes est un système d'automatisation du déploiement, de la mise à l'échelle et de la gestion des applications conteneurisées. Il est également appelé «orchestrateur de conteneurs». Si Kubernetes fonctionne avec des conteneurs, nous devons d'abord acquérir ces conteneurs avant d'utiliser ce système. Mais d'abord, parlons de ce que sont les conteneurs. Peut-être que la meilleure réponse à la question de savoir de quoi il s'agit se trouve dans la documentation de Docker:

Une image de conteneur est un package exécutable léger et autonome contenant une application qui comprend tout ce dont vous avez besoin pour l'exécuter: code d'application, runtime, outils et bibliothèques système et paramètres. Les programmes conteneurisés peuvent être utilisés dans des environnements Linux et Windows, et ils fonctionneront toujours de la même manière, quelle que soit l'infrastructure.

Cela signifie que les conteneurs peuvent être exécutés sur n'importe quel ordinateur, y compris les serveurs de production, et dans n'importe quel environnement, les applications qu'ils contiennent fonctionneront de la même manière.

Afin d'explorer les fonctionnalités des conteneurs et de les comparer avec d'autres façons de lancer des applications, considérez un exemple de service d'une application React à l'aide d'une machine virtuelle et d'un conteneur.

▍Serving React application static files using virtual machine

En essayant d'organiser la maintenance des fichiers statiques au moyen de machines virtuelles, nous rencontrerons les inconvénients suivants:

1. Utilisation inefficace des ressources, car chaque machine virtuelle est un système d'exploitation à part entière.
2. Dépend de la plateforme. Ce qui fonctionne sur un certain ordinateur local peut ne pas fonctionner sur un serveur de production.
3. Mise à l'échelle lente et gourmande en ressources d'une solution basée sur une machine virtuelle.

Serveur Web Nginx static server s'exécutant sur une machine virtuelle

Si les conteneurs sont utilisés pour résoudre un problème similaire, alors, par rapport aux machines virtuelles, leurs forces suivantes peuvent être notées:

1. Utilisation efficace des ressources: travailler avec le système d'exploitation à l'aide de Docker.
2. Indépendance de la plateforme. Un conteneur qu'un développeur peut exécuter sur son ordinateur fonctionnera n'importe où.
3. Déploiement léger grâce à l'utilisation de couches d'image.

Serveur Web Nginx static server s'exécutant dans un conteneur

Nous n'avons comparé les machines virtuelles et les conteneurs que sur quelques points, mais même cela suffit pour ressentir les points forts des conteneurs. En savoir plus sur les conteneurs Docker ici.

▍ Assemblage d'une image de conteneur pour une application React

Le bloc de construction principal du conteneur Docker est le Dockerfile . Au début de ce fichier, enregistrez l'image de base du conteneur, puis incluez une séquence d'instructions qui indique l'ordre dans lequel le conteneur sera créé et qui répondra aux besoins d'une certaine application.

Avant de Dockerfile à travailler avec le Dockerfile , rappelons-nous ce que nous avons fait afin de préparer les fichiers d'application React à télécharger sur le serveur Nginx:

1. Créez un package d'application React ( npm run build ).
2. Démarrage du serveur Nginx.
3. Copiez le contenu du répertoire de build du dossier du projet sa-frontend dans le dossier du serveur nginx/html .

Ci-dessous, vous pouvez voir les parallèles entre la création du conteneur et les actions ci-dessus effectuées sur l'ordinateur local.

▍Préparation d'un Dockerfile pour SA-Frontend

Les instructions qui seront contenues dans le Dockerfile pour l'application SA-Frontend consistent en seulement deux commandes. Le fait est que l'équipe de développement de Nginx a préparé une image de base pour Nginx, que nous utiliserons pour créer notre image. Voici les deux étapes que nous devons décrire:

1. La base de l'image dont vous avez besoin pour créer l'image de Nginx.
2. Le contenu du dossier sa-frontend/build doit être copié dans le dossier image nginx/html .

Si nous passons de cette description au Dockerfile , cela ressemblera à ceci:

 FROM nginx COPY build /usr/share/nginx/html 

Comme vous pouvez le voir, tout est très simple ici, tandis que le contenu du fichier est même assez lisible et compréhensible. Ce fichier indique au système de prendre l'image nginx avec tout ce qu'il possède déjà et de copier le contenu du répertoire de build répertoire nginx/html .

Ici, vous pouvez avoir une question concernant d'où je sais exactement où copier les fichiers du dossier de build , c'est-à-dire d'où vient le chemin /usr/share/nginx/html . En fait, et il n'y a rien de compliqué. Le fait est que les informations pertinentes peuvent être trouvées dans la description de l' image.

▍Construction d'une image et téléchargement vers le référentiel

Avant de pouvoir travailler avec l'image finie, nous devons l'envoyer au référentiel d'images. Pour ce faire, nous utiliserons la plateforme cloud gratuite pour l'hébergement des images Docker Hub. À ce stade du travail, vous devez effectuer les opérations suivantes:

1. Installez Docker .
2. Inscrivez-vous sur le site Web de Docker Hub.
3. Connectez-vous au compte en exécutant la commande suivante dans le terminal:
   
   

    docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD" 

Vous devez maintenant utiliser le terminal pour accéder au répertoire sa-frontend et y exécuter la commande suivante:

 docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend . 

Ci-après dans des commandes similaires, $DOCKER_USER_ID doit être remplacé par votre nom d'utilisateur sur le Docker Hub. Par exemple, cette partie de la commande pourrait ressembler à ceci: rinormaloku/sentiment-analysis-frontend .

Dans le même temps, cette commande peut être raccourcie en supprimant -f Dockerfile , car ce fichier existe déjà dans le dossier dans lequel nous exécutons cette commande.

Afin d'envoyer l'image finie au référentiel, nous avons besoin de la commande suivante:

 docker push $DOCKER_USER_ID/sentiment-analysis-frontend 

Après son exécution, vérifiez la liste de vos référentiels sur le Docker Hub afin de comprendre si l'image a été envoyée avec succès dans le cloud.

▍Démarrer le conteneur

Désormais, n'importe qui peut télécharger et exécuter une image connue sous le nom de $DOCKER_USER_ID/sentiment-analysis-frontend . Pour ce faire, vous devez exécuter la séquence de commandes suivante:

 docker pull $DOCKER_USER_ID/sentiment-analysis-frontend docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend 

Maintenant, le conteneur est lancé et nous pouvons continuer à travailler, créant les autres images dont nous avons besoin. Mais, avant de continuer, 80:80 construction 80:80 , qui se trouve dans la commande de lancement d'image et peut sembler incompréhensible.

• Le premier numéro 80 est le numéro de port hôte (c'est-à-dire l'ordinateur local).
• Le deuxième numéro 80 est le port du conteneur vers lequel la demande doit être redirigée.

Considérez l'illustration suivante.


Transfert de port

Le système redirige les demandes du port <hostPort> vers le port <containerPort> . Autrement dit, l'accès au port 80 ordinateur est redirigé vers le port 80 conteneur.

Le port 80 ouvert sur l'ordinateur local, vous pouvez accéder à l'application à partir de cet ordinateur sur localhost:80 . Si votre système ne prend pas en charge Docker, vous pouvez exécuter l'application sur la machine virtuelle Docker, dont l'adresse ressemblera à <docker-machine ip>:80 . Afin de découvrir l'adresse IP de la machine virtuelle Docker, vous pouvez utiliser la commande docker-machine ip .

À ce stade, après avoir lancé avec succès le conteneur d'application frontale, vous devriez pouvoir ouvrir sa page dans un navigateur.

▍ Fichier .dockerignore

En collectant l'image de l'application SA-Frontend , nous avons pu remarquer que ce processus est extrêmement lent. Cela se produit du fait que le contexte de génération de l'image doit être envoyé au démon Docker. Le répertoire représentant le contexte de génération est spécifié par le dernier argument de la docker build . Dans notre cas, à la fin de cette commande est un point. Il en résulte que la structure suivante est incluse dans le contexte d'assemblage:

 sa-frontend: |   .dockerignore |   Dockerfile |   package.json |   README.md +---build +---node_modules +---public \---src 

Mais de tous les dossiers présents ici, nous n'avons besoin que du dossier de build . Télécharger quoi que ce soit d'autre est une perte de temps. Les builds peuvent être accélérés en indiquant à Docker quels répertoires ignorer. C'est pour cela que nous avons besoin d'un fichier .dockerignore . Si vous connaissez le fichier .gitignore , la structure de ce fichier vous semblera sûrement familière. Il répertorie les répertoires que le système d'assemblage d'images peut ignorer. Dans notre cas, le contenu de ce fichier ressemble à ceci:

 node_modules src public 

Le fichier .dockerignore doit se trouver dans le même dossier que le Dockerfile . L'assemblage de l'image prendra maintenant quelques secondes.

Jetons maintenant un œil à l'application Java.

▍ Java-

, . .

Dockerfile , sa-webapp . , , ENV EXPOSE :

 ENV SA_LOGIC_API_URL http://localhost:5000 … EXPOSE 8080 

ENV Docker. , URL API , .

EXPOSE Docker , . . , Dockerfile SA-Frontend . , , , Dockerfile .

, . — README.md sa-webapp .

▍ Python-

Dockerfile sa-logic , . , , , README.md sa-logic .

▍

- , ? . .

1. sa-logic 5050 :
   
   

    docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic 

2. sa-webapp 8080 . , , Python- Java-, SA_LOGIC_API_URL :
   
   

    $ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app 

, IP- Docker — README .

sa-frontend :

 docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend 

, localhost:80 .

, sa-webapp , Docker, App.js sa-frontend , IP- analyzeSentence() , . .

.

: Kubernetes?

Dockerfile , , Docker. , , .dockerignore . Docker. , Kubernetes. . :
, - . . , sa-webapp sa-logic . , ?