À notre demande, Habr a créé un hub et nous sommes ravis de publier le premier article dans celui-ci. Abonnez-vous !
Kubernetes, c'est simple. Pourquoi alors 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 ?
Si vous doutez que Kubernetes puisse être appris aussi rapidement, je vous propose d'essayer vous-même. En maîtrisant ce matériel, vous serez capable de lancer une application basée sur des microservices dans un cluster Kubernetes. Je peux le garantir, car c'est exactement selon cette méthode, utilisée ici, que j'enseigne Kubernetes à nos clients. Qu'est-ce qui distingue ce guide des autres ? En réalité, c'est beaucoup de choses. La plupart des matériaux similaires commencent par expliquer des choses simples — les concepts de Kubernetes et les particularités de la commande kubectl. Les auteurs de ces matériaux supposent que leur lecteur est familier avec le développement d’applications, les microservices et les conteneurs Docker. Nous allons cependant prendre un autre chemin. Nous parlerons d'abord de la façon de lancer une application basée sur des microservices sur un ordinateur. Ensuite, nous examinerons la construction d'images de conteneurs pour chaque microservice. Et ce n'est qu'après cela que nous découvrirons Kubernetes et aborderons le déploiement d'une application basée sur des microservices dans un cluster géré par Kubernetes.
Cette approche, s'approchant progressivement de Kubernetes, donnera la profondeur de compréhension nécessaire à une personne ordinaire pour comprendre à quel point tout est simple dans Kubernetes. Kubernetes est sans aucun doute une technologie simple, à condition que celui qui souhaite l'apprendre sache où et comment elle est utilisée.
Maintenant, sans plus tarder, passons à l'action et parlons de l'application avec laquelle nous allons travailler.
Application expérimentale
Notre application n'aura qu'une seule fonction. Elle prend en entrée une phrase, puis, en utilisant des outils d'analyse de texte, réalise une analyse de sentiment 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 pour l'analyse de sentiment des textes
D'un point de vue technique, l'application se compose de trois microservices, chacun résolvant un ensemble de tâches spécifique :
- SA-Frontend — serveur web Nginx qui sert des fichiers statiques React.
- SA-WebApp — application web écrite en Java qui traite les requêtes du frontend.
- SA-Logic — application Python qui effectue l'analyse de polarité du texte.
Il est important de noter que les microservices n'existent pas en isolation. Ils réalisent l'idée de « séparation des responsabilités », mais ils doivent interagir les uns avec les autres.
Flux de données dans l'application
Dans le schéma ci-dessus, vous pouvez voir les étapes numérotées du fonctionnement du système, illustrant les flux de données dans l'application. Analysons-les :
- Le navigateur demande au serveur un fichier
index.html(qui, à son tour, charge le paquet de l'application React). - L'utilisateur interagit avec l'application, ce qui appelle une requête à l'application web basée sur Spring.
- L'application web redirige la demande à l'application Python pour effectuer l'analyse de texte.
- L'application Python effectue l'analyse de polarité du texte et renvoie le résultat en réponse à la demande.
- L'application Spring envoie la réponse à l'application React (qui, à son tour, affiche le résultat de l'analyse du texte à l'utilisateur).
Le code de toutes ces applications peut être trouvé . Je vous recommande de copier ce dépôt dès maintenant, car nous avons de nombreuses expériences intéressantes à faire avec.
Exécution d'une application basée sur des microservices sur un ordinateur local
Pour que l'application fonctionne, nous devons lancer les trois microservices. Commençons par le plus sympathique d'entre eux — l'application frontend.
▍Configuration de React pour le développement local
Pour exécuter l'application React, vous devez installer sur votre ordinateur la plateforme Node.js et NPM. Une fois tout cela installé, ouvrez le terminal et rendez-vous dans le dossier du projet sa-frontend et exécutez la commande suivante :
npm install En exécutant cette commande, les dépendances de l'application React, mentionnées dans le fichier, seront téléchargées dans le dossier node_modules . Une fois le téléchargement des dépendances terminé, exécutez la commande suivante dans le même dossier : package.jsonnpm start
Voilà, c'est tout. Maintenant l'application React est lancée, vous pouvez y accéder en ouvrant votre navigateur à l'adresse localhost:3000 localhost:3000. Vous pouvez modifier un peu son code. L'effet de ces changements sera immédiatement visible dans le navigateur. Cela est possible grâce à ce que l'on appelle le remplacement à chaud des modules. Grâce à cela, le développement frontend devient une activité simple et agréable.
▍Préparation de l'application React pour la production
Pour un usage réel de l'application React, nous devons la transformer en un ensemble de fichiers statiques et les servir aux clients en utilisant un serveur web.
Pour compiler l'application React, à nouveau, utilisez le terminal et allez dans le dossier sa-frontend et exécutez la commande suivante :
npm run build Cela créera dans le dossier du projet un répertoire build. Celui-ci contiendra tous les fichiers statiques nécessaires au fonctionnement de l'application React.
▍Gestion des fichiers statiques avec Nginx
Tout d'abord, vous devez installer et démarrer le serveur web Nginx. vous pouvez le télécharger et trouver des instructions pour l'installation et le démarrage. Ensuite, copiez le contenu du dossier sa-frontend/build dans le dossier [your_nginx_installation_dir]/html.
Avec cette approche, le fichier généré lors de la compilation de l'application React index.html sera accessible à l'adresse [your_nginx_installation_dir]/html/index.html. C'est le fichier que, par défaut, le serveur Nginx délivre lorsque l'on y accède. Le serveur est configuré pour écouter sur le port 80, mais il peut être configuré selon vos besoins en modifiant le fichier [your_nginx_installation_dir]/conf/nginx.conf.
Maintenant, ouvrez votre navigateur et allez à l'adresse localhost:80. Vous verrez la page de l'application React.
Application React servie par le serveur Nginx
Si vous saisissez quelque chose dans le champ Type your sentence et cliquez sur le bouton Send — rien ne se passera. Cependant, si vous jetez un œil à la console, vous pourrez voir des messages d'erreur. Pour comprendre où ces erreurs se produisent, examinons le code de l'application.
▍Analyse du code de l'application frontend
En regardant le code du fichier App.js, nous pouvons voir que lorsque le bouton Send est cliqué, cela appelle la méthode analyzeSentence(). Le code de cette méthode est présenté ci-dessous. Notez que chaque ligne ayant un commentaire de type # Номер, a une explication fournie ci-dessous 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. Il est supposé qu'il y a une application à cette adresse, attendant des requêtes similaires.
2.Le corps de la requête envoyé à l'application. Voici un exemple de corps de requête :
{
sentence: "J'aime yogobella!"
} 3.Lorsque la réponse à la requête est reçue, l'état du composant est mis à jour. Cela entraîne un nouveau rendu du composant. Si nous recevons des données (c'est-à-dire, un objet JSON contenant les données saisies et l'évaluation calculée du texte), nous afficherons le composant Polarité, car les conditions requises seront remplies. Voici comment nous décrivons le composant :
const polarityComponent = this.state.polarity !== undefined ?
:
null; Le code semble être tout à fait fonctionnel. Qu'est-ce qui ne va donc pas ici ? Si vous supposez qu'à l'adresse à laquelle l'application tente d'envoyer une requête POST, il n'y a rien pour accepter et traiter cette requête, vous avez absolument raison. À savoir, pour traiter les requêtes 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 capable d'accepter une requête POST
▍Configuration de l'application web basée sur Spring
Pour déployer une application Spring, vous aurez besoin de JDK8 et de Maven ainsi que de variables d'environnement correctement configurées. Une fois que tout cela est installé, 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, un répertoire sera créé dans le dossier sa-webapp . Ici, se trouvera l'application Java emballée dans un fichier jar, représentée par le fichier ciblesentiment-analysis-web-0.0.1-SNAPSHOT.jar ▍Exécution de l'application Java.
Accédez au dossier
et démarrez l'application avec la commande suivante : cible java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar
Lors de l'exécution de cette commande, une erreur se produira. Pour commencer à corriger cela, nous pouvons analyser les informations d'exception dans les données de trace de la pile :Lors de l'exécution de cette commande, une erreur se produira. Pour commencer à la corriger, nous pouvons analyser les informations sur l'exception dans les données de la trace de la pile:
Erreur lors de la création du bean avec le nom 'sentimentController' : échec de l'injection des dépendances autowired ; exception imbriquée : java.lang.IllegalArgumentException : impossible de résoudre l'espace réservé 'sa.logic.api.url' dans la valeur "${sa.logic.api.url}" Pour nous, l'élément le plus important ici est la mention de l'impossibilité de déterminer la valeur sa.logic.api.url. Analysons le code où l'erreur se produit.
▍Analyse du code de l'application Java
Voici un 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();
}
}- Dans S
entimentControlleril y a un champsaLogicApiUrl. Sa valeur est définie par la propriétésa.logic.api.url. - Chaîne
saLogicApiUrlse concatène avec la valeur/analyse/sentiment. Ensemble, ils forment une adresse pour effectuer une requête au microservice qui réalise l'analyse de texte.
▍Définition de la valeur de la propriété
Dans Spring, la source standard des valeurs des propriétés est le fichier application.properties, que l'on peut trouver à l'adresse sa-webapp/src/main/resources. Mais son utilisation n'est pas la seule méthode pour définir les valeurs des propriétés. Cela peut aussi être fait avec une commande du type :
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URLLa valeur de cette propriété doit pointer vers l'adresse de notre application Python.
En le configurant, nous informons l'application web Spring où elle doit se rendre pour effectuer des requêtes d'analyse de texte.
Pour ne pas nous compliquer la vie, convenons que l'application Python sera accessible à l'adresse localhost:5000 et essayons 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 
Notre système manque de l'application Python
Il ne nous reste plus qu'à lancer l'application Python et le système fonctionnera comme prévu.
▍Configuration de l'application Python
Pour lancer l'application Python, vous devez avoir Python 3 et Pip installés, et les variables d'environnement correspondantes doivent être correctement configurées.
▍Installation des 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▍Lancement de l'application
Après l'installation des dépendances, nous sommes prêts à lancer l'application :
python sentiment_analysis.pyAprès avoir exécuté cette commande, nous recevons le message suivant :
* En cours d'exécution sur http://0.0.0.0:5000/ (Appuyez sur CTRL+C pour quitter) Cela signifie que l'application est en cours d'exécution et attend des requêtes à l'adresse localhost:5000/
▍Analyse du code
Examinons le code de l'application Python pour comprendre comment elle réagit 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 de l'objet
Flask. - Attribution de l'adresse pour effectuer des requêtes POST.
- Extraction de la propriété
sentencedu corps de la requête. - Initialisation de l'objet anonyme
TextBlobet récupération de la valeurpolaritypour la première phrase reçue dans le corps de la requête (dans notre cas, c'est la seule phrase transmise pour analyse). - Retour de la réponse dont le corps contient le texte de la phrase et la métrique calculée pour celle-ci.
polarity. - Lancement de l'application Flask, qui sera accessible à l'adresse
0.0.0.0:5000(on peut y accéder en utilisant une structure de typelocalhost:5000).
Maintenant, les microservices qui composent l'application sont lancés. Ils sont configurés pour interagir les uns avec les autres. Voici à quoi ressemble le schéma de l'application à ce stade.
Tous les microservices qui composent l'application sont en état de fonctionnement.
Avant de continuer, ouvrez l'application React dans le navigateur et essayez d'analyser une phrase avec elle. Si tout a été fait correctement, après avoir cliqué sur le bouton Send vous verrez les résultats de l'analyse sous le champ de texte.
Dans la section suivante, nous parlerons de la manière de lancer nos microservices dans des conteneurs Docker. Cela est nécessaire pour préparer l'application à être lancée dans un cluster Kubernetes.
Conteneurs Docker
— est un système pour l'automatisation du déploiement, de la mise à l'échelle et de la gestion des applications conteneurisées. On l'appelle également « orchestrateur de conteneurs » (container orchestrator). Si Kubernetes travaille avec des conteneurs, alors avant de pouvoir utiliser ce système, nous devons d'abord nous procurer ces conteneurs. Mais d'abord, parlons de ce que sont les conteneurs. La meilleure réponse à la question de ce que c'est peut sans doute être trouvée dans Docker :
Une image de conteneur est un paquet léger, autonome et exécutable contenant une certaine application, qui inclut tout le nécessaire pour son exécution : le code de l'application, l'environnement d'exécution, les outils système et les bibliothèques, ainsi que les configurations. Les programmes conteneurisés peuvent être utilisés dans des environnements Linux et Windows, et fonctionneront toujours de la même manière, peu importe l'infrastructure.
Cela signifie que les conteneurs peuvent être exécutés sur n'importe quel ordinateur, y compris sur des serveurs de production, et dans tous les environnements, les applications qu'ils contiennent fonctionneront de manière homogène.
Pour explorer les caractéristiques des conteneurs et les comparer à d'autres méthodes d'exécution d'applications, examinons l'exemple de la gestion d'une application React en utilisant une machine virtuelle et un conteneur.
▍Gestion des fichiers statiques d'une application React à l'aide d'une machine virtuelle
En essayant d'organiser la gestion des fichiers statiques à l'aide de machines virtuelles, nous rencontrerons les inconvénients suivants :
- Utilisation inefficace des ressources, car chaque machine virtuelle représente un système d'exploitation complet.
- Dépendance à la plateforme. Ce qui fonctionne sur un certain ordinateur local peut ne pas fonctionner sur un serveur de production.
- Scalabilité lente et exigeante en ressources d'une solution basée sur des machines virtuelles.
Un serveur web Nginx gérant des fichiers statiques, exécuté sur une machine virtuelle
Si l'on utilise des conteneurs pour résoudre une tâche similaire, en comparaison avec des machines virtuelles, on peut noter les avantages suivants :
- Utilisation efficace des ressources : travailler avec le système d'exploitation via Docker.
- Indépendance par rapport aux plateformes. Un conteneur que le développeur peut exécuter sur son ordinateur fonctionnera partout.
- Déploiement léger grâce à l'utilisation de couches d'images.
Serveur web Nginx servant des fichiers statiques, exécuté dans un conteneur.
Nous avons comparé les machines virtuelles et les conteneurs sur quelques points seulement, mais même cela suffit pour ressentir les avantages des conteneurs. vous pouvez trouver des détails sur les conteneurs Docker.
▍Construction de l'image du conteneur pour l'application React.
Le principal élément constitutif d'un conteneur Docker est le fichier Dockerfile. Au début de ce fichier, une déclaration concernant l'image de base du conteneur est faite, puis une séquence d'instructions est incluse, indiquant l'ordre de création du conteneur, qui répondra aux besoins d'une application donnée.
Avant de nous attaquer au travail avec le fichier Dockerfile, rappelons ce que nous avons fait pour préparer les fichiers de l'application React pour le déploiement sur le serveur Nginx :
- Construction du paquet de l'application React (
npm run build). - Démarrage du serveur Nginx.
- Copie du contenu du répertoire
builddepuis le dossier du projetsa-frontenddans le dossier du serveurnginx/html.
Vous pourrez voir ci-dessous les parallèles entre la création d'un conteneur et les actions décrites ci-dessus, effectuées sur un ordinateur local.
▍Préparation du fichier Dockerfile pour l'application SA-Frontend.
Les instructions qui seront contenues dans Dockerfile pour l'application SA-Frontend, se composent de seulement deux commandes. En effet, l'équipe de développeurs Nginx a préparé un modèle de base pour Nginx, que nous allons utiliser pour créer notre image. Voici les deux étapes que nous devons décrire :
- La base de l'image doit être l'image Nginx.
- Le contenu du dossier
sa-frontend/builddoit être copié dans le dossier de l'imagenginx/html.
Si l'on passe de cette description au fichier Dockerfile, il apparaîtra comme suit :
FROM nginx
COPY build /usr/share/nginx/html Comme vous pouvez le constater, tout est très simple, et le contenu du fichier s'avère même assez lisible et compréhensible. Ce fichier indique au système qu'il doit prendre l'image nginx avec tout ce qu'elle contient déjà, et copier le contenu du répertoire build dans le répertoire nginx/html.
Ici, vous pourriez vous interroger sur la manière dont je sais exactement où copier les fichiers depuis le dossier build, c'est-à-dire d'où vient le chemin /usr/share/nginx/html. En réalité, il n'y a là rien de compliqué. En fait, les informations correspondantes peuvent être trouvées dans de l'image.
▍Création de l'image et chargement dans le dépôt
Avant de pouvoir travailler avec l'image prête, nous devons l'envoyer au dépôt d'images. Pour cela, nous utiliserons la plateforme cloud gratuite pour l'hébergement d'images Docker Hub. À ce stade, vous devez faire ce qui suit :
- Installer .
- Inscrivez-vous sur le site de Docker Hub.
- Connectez-vous à votre compte en exécutant dans le terminal une commande du type :
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
Maintenant, vous devez naviguer dans le répertoire sa-frontend et exécuter là-bas une commande du type :
docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend . Ici et dans les commandes similaires à l'avenir, $DOCKER_USER_ID doit être remplacé par votre nom d'utilisateur sur Docker Hub. Par exemple, cette partie de la commande pourrait ressembler à : rinormaloku/sentiment-analysis-frontend.
De plus, cette commande peut être raccourcie en supprimant -f Dockerfile, car le fichier est déjà présent dans le dossier où nous exécutons cette commande.
Pour envoyer l'image prête au dépôt, nous aurons besoin de la commande suivante :
docker push $DOCKER_USER_ID/sentiment-analysis-frontendAprès son exécution, vérifiez la liste de vos dépôts sur Docker Hub pour comprendre si l'envoi de l'image a réussi vers le stockage cloud.
▍Lancement du conteneur
Maintenant, 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, il faut 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 Le conteneur est maintenant en cours d'exécution et nous pouvons continuer à travailler en créant d'autres images dont nous avons besoin. Mais avant de continuer, examinons la structure 80:80, qui apparaît dans la commande de lancement de l'image et peut sembler confuse.
- Le premier nombre
80représente le numéro du port de l'hôte (c'est-à-dire de l'ordinateur local). - Le deuxième nombre
80est le port du conteneur, sur lequel la requête doit être redirigée.
Considérons l'illustration suivante.
Redirection des ports
Le système redirige les requêtes du port <hostPort> vers le port .Autrement dit, une demande au port 80 de l'ordinateur est redirigée vers le port 80 du conteneur.
Étant donné que le port 80 est ouvert sur l'ordinateur local, il est possible d'accéder à l'application à partir de cet ordinateur à l'adresse localhost:80. Si votre système ne prend pas en charge Docker, l'application peut être exécutée sur une machine virtuelle Docker, dont l'adresse apparaîtra comme :80. Pour connaître l'adresse IP de la machine virtuelle Docker, vous pouvez utiliser la commande docker-machine ip.
À ce stade, après le démarrage réussi du conteneur de l'application frontend, vous devriez être en mesure d'ouvrir sa page dans le navigateur.
▍Fichier .dockerignore
Lors de la construction de l'image de l'application SA-Frontend, nous avons pu remarquer que ce processus était extrêmement lent. Cela est dû au fait que le démon Docker doit recevoir le contexte de construction de l'image. Le répertoire qui représente le contexte de construction est spécifié comme le dernier argument de la commande docker build. Dans notre cas, un point se trouve à la fin de cette commande. Cela signifie que la structure suivante est incluse dans le contexte de construction :
sa-frontend:
| .dockerignore
| Dockerfile
| package.json
| README.md
+---build
+---node_modules
+---public
---src Mais nous n'avons besoin que du dossier build. Télécharger quoi que ce soit d'autre serait une perte de temps. Le processus de construction peut être accéléré en indiquant à Docker quels répertoires peuvent être ignorés. C'est précisément pour cela que nous avons besoin du fichier .dockerignore. Si vous êtes familier avec le fichier .gitignore, la structure de ce fichier vous semblera sûrement familière. Il énumère les répertoires que le système de construction de l'image 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 fichier Dockerfile. Maintenant, la construction de l'image prendra quelques secondes.
Passons maintenant à l'image pour l'application Java.
▍Construction de l'image de conteneur pour l'application Java
Vous savez quoi, vous avez déjà appris tout ce qu'il faut pour créer des images de conteneurs. C'est pourquoi cette section sera assez courte.
Ouvrez le fichier Dockerfile, qui se trouve dans le dossier du projet sa-webapp. Si vous lisez le texte de ce fichier, vous rencontrerez seulement deux nouvelles constructions, commençant par les mots-clés ENV et EXPOSE:
ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080 Le mot-clé ENV permet de déclarer des variables d'environnement à l'intérieur des conteneurs Docker. En particulier, dans notre cas, il permet de spécifier l'URL pour accéder à l'API de l'application effectuant l'analyse de texte.
Le mot-clé EXPOSE permet d'indiquer à Docker quel port doit être ouvert. Nous allons utiliser ce port lors du traitement de l'application. On peut remarquer ici que dans Dockerfile pour l'application SA-Frontend cette commande n'existe pas. Cela est nécessaire uniquement à des fins de documentation, en d'autres termes, cette construction est destinée à ceux qui vont lire Dockerfile.
La construction de l'image et son envoi dans le dépôt se fait exactement comme dans l'exemple précédent. Si vous n'êtes pas encore très sûr de vos capacités, les commandes correspondantes peuvent être trouvées dans le fichier README.md dans le dossier sa-webapp.
▍Construction d'une image de conteneur pour une application Python
Si vous jetez un œil au contenu du fichier Dockerfile dans le dossier sa-logic, vous n'y découvrirez rien de nouveau. Les commandes pour construire l'image et l'envoyer dans le dépôt devraient également vous être familières, mais elles peuvent, comme pour nos autres applications, ê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é ? Moi non plus. Testons nos conteneurs.
- Nous allons lancer le conteneur de l'application
sa-logicet le configurer pour écouter sur le port5050:docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic - Nous allons lancer le conteneur de l'application
sa-webappet le configurer pour écouter sur le port8080. De plus, nous devons configurer le port sur lequel l'application Python attendra des requêtes de l'application Java, en réaffectant la variable d'environnementSA_LOGIC_API_URL:$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
Pour savoir comment découvrir l'adresse IP du conteneur ou de la machine virtuelle Docker, consultez le fichier .
Nous allons lancer le conteneur de l'application sa-frontend:
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend Votre configuration est maintenant prête pour aller dans le navigateur à l'adresse localhost:80 et tester l'application.
Notez que si vous avez changé le port pour sa-webapp, ou si vous travaillez avec une machine virtuelle Docker, vous devrez modifier le fichier App.js dans le dossier sa-frontend, en remplaçant l'adresse IP ou le numéro de port dans la méthode analyzeSentence(), en mettant à jour les anciennes données avec des informations actuelles. Ensuite, vous devez à nouveau construire l'image et l'utiliser.
Voici à quoi ressemble le schéma de notre application maintenant.
Les microservices s'exécutent dans des conteneurs
Résultats : pourquoi avoir besoin d'un cluster Kubernetes ?
Nous avons à peine étudié les fichiers Dockerfile, avons parlé de la façon de construire des images et de les envoyer dans le dépôt Docker. De plus, nous avons appris à accélérer la construction des images en utilisant le fichier .dockerignoreEn fin de compte, nos microservices s'exécutent désormais dans des conteneurs Docker. Vous pourriez avoir une question légitime sur l'utilité de Kubernetes. La réponse à cette question sera abordée dans 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 mondialement populaire. Des millions de requêtes lui parviennent chaque minute. Cela signifie que les microservices sa-webapp et sa-logic seront soumis à une énorme charge. Comment évoluer les conteneurs dans lesquels s'exécutent les microservices ?
Source : habr.com
