🥇Tutoriel Kubernetes Partie 1 : Applications, microservices et conteneurs

A notre demande, Habr a créé un hub Kubernetes et nous sommes heureux d'y placer la première publication. S'abonner!

Kubernetes est simple. Pourquoi les banques me paient-elles très cher 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, ayant maîtrisé ce matériel, vous serez capable de faire tourner une application basée sur des microservices dans un cluster Kubernetes. Je peux le garantir, car c'est dans la même méthodologie que j'utilise ici que j'enseigne à nos clients comment travailler avec Kubernetes. Qu'est-ce qui différencie ce guide 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 la commande kubectl. Les auteurs de ces articles supposent que leur lecteur est familiarisé avec 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. Ensuite, nous examinerons la création d'images de conteneurs pour chaque microservice. Et après cela, nous nous familiariserons avec Kubernetes et analyserons le déploiement d'une application basée sur des microservices dans un cluster géré par Kubernetes.

Cette approche, avec une approche progressive de Kubernetes, donnera la profondeur de compréhension de ce qui se passe dont la personne moyenne a besoin pour comprendre comment tout est arrangé simplement dans Kubernetes. Kubernetes est certes une technologie simple, à condition que celui qui veut la maîtriser sache où et comment elle est utilisée.

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

Application expérimentale

Notre application n'effectuera qu'une seule fonction. Il prend, en entrée, une phrase, après quoi, à l'aide d'outils d'analyse de texte, il effectue une analyse des sentiments de cette phrase, obtenant une évaluation 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 d'analyse des sentiments

D'un point de vue technique, l'application se compose de trois microservices, dont chacun résout 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 écrite en Java qui gère les requêtes du frontend.
SA-Logic est une application Python qui effectue une analyse des sentiments textuels.

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 en même temps interagir les uns avec les autres.

Flux de données dans l'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. Décomposons-les :

Le navigateur demande un fichier au serveur index.html (qui à son tour charge le package d'application React).
L'utilisateur interagit avec l'application, cela provoque un appel à une application web basée sur Spring.
L'application Web transmet la demande d'analyse du texte à l'application Python.
L'application Python analyse le sentiment du texte et renvoie le résultat en réponse à la requête.
L'application Spring envoie une réponse à l'application React (qui, à son tour, montre le résultat du texte analysé à l'utilisateur).

Le code de toutes ces applications se trouve ici. Je vous recommande de copier ce référentiel sur vous-même dès maintenant, car de nombreuses expériences intéressantes nous attendent.

Exécuter une application basée sur des microservices sur la machine locale

Pour que l'application fonctionne, nous devons démarrer les trois microservices. Commençons par la plus jolie d'entre elles - l'application frontale.

▍Mise en place de React pour le développement local

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

npm install

En exécutant cette commande dans le dossier node_modules les dépendances de l'application React seront chargées, dont les enregistrements sont dans le fichier package.json. Après avoir téléchargé les dépendances dans le même dossier, exécutez la commande suivante :

npm start

C'est tout. L'application React est maintenant en cours d'exécution et est accessible en naviguant vers l'adresse du navigateur localhost:3000. 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 front-end se transforme en une expérience simple et agréable.

▍Préparer une application React pour la production

Dans le but d'utiliser réellement une application React, nous devons la convertir en un ensemble de fichiers statiques et les servir aux clients utilisant un serveur Web.

Pour créer l'application React, toujours à 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 dans le dossier du projet build. Il contiendra tous les fichiers statiques nécessaires au fonctionnement de l'application React.

▍Servir des fichiers statiques avec Nginx

Vous devez d'abord installer et exécuter le serveur Web Nginx. il est vous pouvez le télécharger et trouver des instructions pour l'installer et l'exécuter. Ensuite, vous devez copier le contenu du dossier sa-frontend/build au dossier [your_nginx_installation_dir]/html.

Avec cette approche, le fichier généré lors de l'assemblage de l'application React index.html sera disponible à [your_nginx_installation_dir]/html/index.html. Il s'agit du fichier que, par défaut, le serveur Nginx émet lorsqu'il y accède. Le serveur est configuré pour écouter sur un port 80, mais vous pouvez le personnaliser comme vous le souhaitez en modifiant le fichier [your_nginx_installation_dir]/conf/nginx.conf.

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

Application React servie par le serveur Nginx

Si vous entrez maintenant quelque chose dans le champ Type your sentence et appuyez 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 front-end

En regardant le code du fichier App.js, nous pouvons voir qu'en cliquant sur le bouton Send appelle une méthode analyzeSentence(). Le code de cette méthode est présenté ci-dessous. En même temps, faites attention au fait que pour chaque ligne à laquelle il y a un commentaire de la forme # Номер, il y a une explication donnée sous le code. De la même manière, nous analyserons d'autres fragments 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. L'URL à laquelle la requête POST est effectuée. Cette adresse est supposée être une application en attente de telles requêtes.

2.Le corps de la requête envoyé à l'application. Voici un exemple de corps de requête :

{
    sentence: "I like yogobella!"
}

3.Lorsqu'une réponse à une requête est reçue, 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 saisies et le score de texte calculé), nous produirons le composant Polaritytant que les conditions sont 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, de toute façon ? Si vous supposez qu'à l'adresse à laquelle l'application essaie d'envoyer une requête POST, il n'y a encore rien qui puisse accepter et traiter cette requête, alors vous aurez tout à fait raison. A 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 requête POST

▍Mise en place d'une application web basée sur Spring

Pour déployer une application Spring, vous avez 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

Naviguez, à l'aide du terminal, jusqu'au dossier sa-webapp et saisissez la commande suivante :

mvn install

Après avoir exécuté cette commande dans le dossier sa-webapp répertoire sera créé target. C'est là que se trouvera l'application Java, conditionnée dans un fichier jar, représenté par le fichier sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Lancement d'une application Java

Aller au dossier target et exécutez 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 détails de l'exception dans les données de trace de la 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, le plus important ici est la mention de l'impossibilité de clarifier le sens sa.logic.api.url. Analysons le code où l'erreur se produit.

▍Analyse du code des applications 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();
    }
}

En SentimentController il y a un champ saLogicApiUrl. Sa valeur est définie par la propriété sa.logic.api.url.
Rangée saLogicApiUrl concatène avec la valeur /analyse/sentiment. Ensemble, ils forment une adresse pour appeler le microservice qui effectue l'analyse de texte.

▍Définition d'une valeur de propriété

Dans Spring, la source par défaut des valeurs de propriété est un fichier application.properties, que l'on peut trouver sur sa-webapp/src/main/resources. Mais l'utiliser n'est pas le seul moyen de définir des valeurs de propriété. Vous pouvez également le faire avec la commande 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 requêtes d'analyse de texte.

Afin de ne pas nous compliquer la vie, nous allons décider que l'application Python sera disponible sur localhost:5000 et essayez de ne pas l'oublier. Par conséquent, la commande pour démarrer l'application Spring ressemblera à ceci :

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

Il manque une application Python à notre système

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

▍Mise en place d'une application Python

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

▍Installer les dépendances

Aller 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

▍Lancement de l'application

Une fois les dépendances installées, nous sommes prêts à exécuter l'application :

python sentiment_analysis.py

Après avoir exécuté cette commande, on nous dira ce qui suit :

* 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 des demandes à localhost:5000/

▍Recherche de code

Regardons le code de l'application Python afin de comprendre comment il répond aux requêtes :

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

Initialisation d'objet Flask.
Spécifier l'adresse pour lui faire des requêtes POST.
Récupérer une propriété sentence du corps de la requête.
Initialisation d'objet anonyme TextBlob et obtenir la valeur polarity pour la première proposition reçue dans le corps de la demande (dans notre cas, il s'agit de la seule proposition soumise pour analyse).
Renvoyer une réponse dont le corps contient le texte de l'offre et l'indicateur calculé pour celle-ci polarity.
Lancement de l'application Flask, qui sera disponible sur 0.0.0.0:5000 (vous pouvez également y accéder à l'aide d'une construction 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 schéma d'application à ce stade du travail.

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

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

Dans la section suivante, nous verrons comment exécuter nos microservices dans des conteneurs Docker. Cela est nécessaire pour préparer l'exécution 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, alors avant d'utiliser ce système, nous devons d'abord acquérir ces conteneurs. Mais d'abord, parlons de ce que sont les conteneurs. Peut-être que la meilleure réponse à la question de savoir ce que c'est peut être trouvée dans documentation à Docker :

Une image de conteneur est un package léger, autonome et exécutable qui contient une application, qui comprend tout ce qui est nécessaire pour l'exécuter : code de l'application, environnement d'exécution, outils et bibliothèques système, paramètres. Les programmes conteneurisés peuvent être utilisés dans les environnements Linux et Windows et 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.

Pour explorer les fonctionnalités des conteneurs et les comparer à d'autres façons d'exécuter des applications, examinons l'exemple du service d'une application React à l'aide d'une machine virtuelle et d'un conteneur.

▍Servir des fichiers statiques d'une application React à l'aide d'une machine virtuelle

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

Utilisation inefficace des ressources, puisque chaque machine virtuelle est un système d'exploitation complet.
Dépendance à la plateforme. Ce qui fonctionne sur un certain ordinateur local peut très bien ne pas fonctionner sur un serveur de production.
Mise à l'échelle lente et gourmande en ressources d'une solution de machine virtuelle.

Serveur Web Nginx servant des fichiers statiques exécutés dans une machine virtuelle

Si des conteneurs sont utilisés pour résoudre un problème similaire, alors, par rapport aux machines virtuelles, on peut noter les points forts suivants :

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

Serveur Web Nginx servant des fichiers statiques exécutés dans un conteneur

Nous n'avons comparé les machines virtuelles et les conteneurs que sur quelques points, mais même cela suffit pour avoir une idée des points forts des conteneurs. il est Vous pouvez trouver des détails sur les conteneurs Docker.

▍Construire une image de conteneur pour une application React

Le bloc de construction de base d'un conteneur Docker est le fichier Dockerfile. Au début de ce fichier, une image de base du conteneur est enregistrée, puis une séquence d'instructions est incluse indiquant comment créer un conteneur qui répondra aux besoins d'une application.

Avant de commencer à travailler avec le fichier Dockerfile, rappelez-vous ce que nous avons fait afin de préparer les fichiers de l'application React pour le téléchargement sur le serveur Nginx :

Construire un package d'application React (npm run build).
Démarrage du serveur Nginx.
Copier le contenu d'un répertoire build du dossier du projet sa-frontend au dossier du serveur nginx/html.

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

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

Instructions à inclure dans Dockerfile pour l'application SA-Frontend, se composent de seulement deux équipes. Le fait est que l'équipe de développement de Nginx a préparé une base image pour Nginx, que nous utiliserons pour construire notre image. Voici les deux étapes que nous devons décrire :

Vous devez faire de l'image Nginx la base de l'image.
Contenu du dossier sa-frontend/build besoin de copier dans le dossier image nginx/html.

Si l'on passe de cette description au fichier Dockerfile, alors ça ressemblera à ça :

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

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

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

▍Assemblage de l'image et téléchargement dans le référentiel

Avant de pouvoir travailler avec une image terminée, nous devons la soumettre au référentiel d'images. Pour ce faire, nous utiliserons la plate-forme gratuite d'hébergement d'images basée sur le cloud Docker Hub. À ce stade du travail, vous devez effectuer les opérations suivantes :

Installer Docker.
Inscrivez-vous sur le site Docker Hub.
Connectez-vous à votre compte en exécutant la commande suivante dans le terminal :
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Maintenant, vous devez, à l'aide du terminal, aller dans le répertoire sa-frontend et exécutez-y la commande suivante :

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

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

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

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 l'avoir terminé, vérifiez votre liste de référentiels sur Docker Hub pour voir si l'image a été transférée avec succès vers le stockage en nuage.

▍Démarrage d'un conteneur

Désormais, n'importe qui peut télécharger et exécuter l'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 en cours d'exécution et nous pouvons continuer à travailler en créant d'autres images dont nous avons besoin. Mais avant de continuer, comprenons le design 80:80, qui se trouve dans la commande pour exécuter l'image et peut sembler déroutant.

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

Considérez l'illustration suivante.

Redirection de port

Le système transfère les demandes du port <hostPort> au port <containerPort>. C'est-à-dire accéder au port 80 l'ordinateur est redirigé vers un port 80 récipient.

Depuis le port 80 ouvert sur l'ordinateur local, vous pouvez accéder à l'application depuis cet ordinateur à localhost:80. Si votre système ne prend pas en charge Docker, vous pouvez exécuter l'application sur une machine virtuelle Docker, dont l'adresse ressemblera à <docker-machine ip>:80. Pour connaître l'adresse IP de la machine virtuelle Docker, vous pouvez utiliser la commande docker-machine ip.

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

▍.dockerignore le fichier

Construire l'image de l'application SA-Frontend, nous avons pu remarquer que ce processus est extrêmement lent. En effet, le contexte de génération d'image doit être envoyé au démon Docker. Le répertoire qui représente le contexte de construction est donné comme dernier argument de la commande docker build. Dans notre cas, il y a un point à la fin de cette commande. 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 d'un dossier build. Télécharger autre chose est une perte de temps. Vous pouvez accélérer la construction en indiquant à Docker les répertoires à ignorer. Pour ce faire, nous avons besoin d'un fichier .dockerignore. Vous, si vous connaissez le dossier .gitignore, la structure de ce fichier vous semblera probablement familière. Il répertorie les répertoires que le système de construction d'image peut ignorer. Dans notre cas, le contenu de ce fichier ressemble à ceci :

node_modules
src
public

Dossier .dockerignore doit être dans le même dossier que le fichier Dockerfile. Maintenant, l'assemblage de l'image prendra quelques secondes.

Traitons maintenant de l'image pour une application Java.

▍Construire une image de conteneur pour une application Java

Vous savez quoi, et vous avez déjà appris tout ce dont vous avez besoin pour créer des images de conteneurs. C'est pourquoi cette section sera très courte.

Ouvrir le fichier Dockerfile, qui se trouve dans le dossier du projet sa-webapp. Si vous lisez le texte de ce fichier, vous n'y rencontrerez que deux nouvelles constructions commençant par des mots-clés ENV и EXPOSE:

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

Ключевое слово ENV vous permet de déclarer des variables d'environnement dans des conteneurs Docker. En particulier, dans notre cas, il vous permet de définir une URL pour accéder à l'API de l'application qui effectue l'analyse de texte.

Ключевое слово EXPOSE vous permet de dire à Docker d'ouvrir un port. Nous allons utiliser ce port pendant que nous travaillons avec l'application. On voit ici que dans Dockerfile pour l'application SA-Frontend il n'y a pas une telle commande. Ceci est uniquement à des fins de documentation, en d'autres termes, cette construction est pour le lecteur Dockerfile.

Construire l'image et la pousser vers le référentiel ressemble exactement à l'exemple précédent. Si vous n'êtes pas encore très confiant dans vos capacités, les commandes correspondantes se trouvent dans le fichier README.md dans le dossier sa-webapp.

▍Construire une image de conteneur pour une application Python

Si vous regardez le contenu du fichier Dockerfile dans le dossier sa-logicvous n'y trouverez rien de nouveau. Les commandes pour construire l'image et la pousser vers le référentiel devraient également vous être familières, mais, comme c'est le cas avec nos autres applications, elles peuvent être trouvées dans le fichier README.md dans le dossier sa-logic.

▍Test des applications conteneurisées

Pouvez-vous faire confiance à quelque chose que vous n'avez pas testé ? je ne peux pas non plus. Testons nos conteneurs.

Commençons le conteneur d'applications sa-logic et configurez-le pour écouter sur un port 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Commençons le conteneur d'applications sa-webapp et configurez-le pour écouter sur un port 8080. De plus, nous devons définir le port sur lequel l'application Python écoutera les requêtes de l'application Java en réaffectant la variable d'environnement 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
```

Pour savoir comment connaître l'adresse IP d'un conteneur ou d'une VM Docker, reportez-vous au fichier README.

Commençons le conteneur d'applications sa-frontend:

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

Maintenant tout est prêt pour naviguer dans le navigateur jusqu'à l'adresse localhost:80 et testez l'application.

Veuillez noter que si vous modifiez le port pour sa-webapp, ou si vous exécutez une VM Docker, vous devrez modifier le fichier App.js du dossier sa-frontenden modifiant l'adresse IP ou le numéro de port dans la méthode analyzeSentence()en substituant des informations actuelles au lieu de données obsolètes. Après cela, vous devez réassembler l'image et l'utiliser.

Voici à quoi ressemble notre diagramme d'application maintenant.

Microservices exécutés dans des conteneurs

Résumé : pourquoi avons-nous besoin d'un cluster Kubernetes ?

Nous venons d'examiner les fichiers Dockerfile, a expliqué comment créer des images et les transférer vers un référentiel Docker. De plus, nous avons appris à accélérer l'assemblage d'images à l'aide du fichier .dockerignore. Par conséquent, nos microservices fonctionnent désormais dans des conteneurs Docker. Ici, vous pouvez avoir une question tout à fait justifiée sur la raison pour laquelle nous avons besoin de Kubernetes. La réponse à cette question sera consacrée à la deuxième partie de ce matériel. En attendant, réfléchissez à la question suivante :
Supposons que notre application Web d'analyse de texte soit devenue populaire dans le monde entier. Des millions de demandes lui parviennent chaque minute. Cela signifie que les microservices sa-webapp и sa-logic sera soumis à un stress énorme. Comment faire évoluer les conteneurs qui exécutent des microservices ?

Source: habr.com

Tutoriel Kubernetes, partie 1 : Applications, microservices et conteneurs