🥇Tutorial Kubernetes Part 1: aplicacions, microserveis i contenidors

A petició nostra, Habr va crear un centre Kubernetes i ens complau col·locar-hi la primera publicació. Subscriu-te!

Kubernetes és fàcil. Per què els bancs em paguen molts diners per treballar en aquesta àrea, mentre que qualsevol pot dominar aquesta tecnologia en poques hores?

Si dubteu que Kubernetes es pugui aprendre tan ràpidament, us suggereixo que proveu de fer-ho vosaltres mateixos. És a dir, un cop dominat aquest material, podreu executar una aplicació basada en microserveis en un clúster de Kubernetes. Ho puc garantir, perquè és amb la mateixa metodologia que faig servir aquí que ensenyo als nostres clients a treballar amb Kubernetes. Què fa que aquesta guia sigui diferent d'altres? De fet, moltes coses. Per tant, la majoria d'aquests materials comencen amb una explicació de coses senzilles: els conceptes de Kubernetes i les característiques de l'ordre kubectl. Els autors d'aquests articles assumeixen que el seu lector està familiaritzat amb el desenvolupament d'aplicacions, els microserveis i els contenidors Docker. Anirem per un altre camí. Primer, parlem de com executar una aplicació basada en microserveis en un ordinador. A continuació, veurem la creació d'imatges de contenidors per a cada microservei. I després, ens familiaritzarem amb Kubernetes i analitzarem el desplegament d'una aplicació basada en microserveis en un clúster gestionat per Kubernetes.

Aquest enfocament, amb un enfocament gradual a Kubernetes, donarà la profunditat de comprensió del que està succeint que la persona mitjana necessita per entendre amb quina senzillesa tot està disposat a Kubernetes. Sens dubte, Kubernetes és una tecnologia senzilla, sempre que qui la vulgui dominar sàpiga on i com s'utilitza.

Ara, sense més preàmbuls, anem a treballar i parlem de l'aplicació amb la qual treballarem.

Aplicació experimental

La nostra aplicació només realitzarà una funció. Pren, com a entrada, una frase, després de la qual, mitjançant eines d'anàlisi de text, realitza una anàlisi de sentiments d'aquesta frase, obtenint una valoració de l'actitud emocional de l'autor de la frase davant un determinat objecte.

Així és la finestra principal d'aquesta aplicació.

Aplicació web d'anàlisi de sentiments

Des del punt de vista tècnic, l'aplicació consta de tres microserveis, cadascun dels quals resol un determinat conjunt de tasques:

SA-Frontend és un servidor web Nginx que serveix fitxers estàtics de React.
SA-WebApp és una aplicació web escrita en Java que gestiona les sol·licituds del frontend.
SA-Logic és una aplicació de Python que realitza anàlisis de sentiments de text.

És important tenir en compte que els microserveis no existeixen de manera aïllada. Implementen la idea de "separació de deures", però, al mateix temps, necessiten interactuar entre ells.

Flux de dades a l'aplicació

Al diagrama anterior, podeu veure les etapes numerades del sistema, il·lustrant els fluxos de dades de l'aplicació. Anem a desglossar-los:

El navegador demana un fitxer al servidor index.html (que al seu torn carrega el paquet de l'aplicació React).
L'usuari interactua amb l'aplicació, això provoca una trucada a una aplicació web basada en Spring.
L'aplicació web reenvia la sol·licitud per analitzar el text a l'aplicació Python.
L'aplicació Python analitza el sentiment del text i retorna el resultat com a resposta a la sol·licitud.
L'aplicació Spring envia una resposta a l'aplicació React (que, al seu torn, mostra el resultat del text analitzat a l'usuari).

Es pot trobar el codi de totes aquestes aplicacions aquí. Us recomano que copieu aquest repositori ara mateix, ja que hi ha molts experiments interessants per davant.

Execució d'una aplicació basada en microserveis a la màquina local

Perquè l'aplicació funcioni, hem d'iniciar els tres microserveis. Comencem amb el més bonic d'ells: l'aplicació frontal.

▍Configuració de React per al desenvolupament local

Per executar una aplicació React, heu d'instal·lar el framework Node.js i NPM al vostre ordinador. Després d'instal·lar tot això, aneu utilitzant el terminal a la carpeta del projecte sa-frontend i executeu l'ordre següent:

npm install

Executant aquesta ordre a la carpeta node_modules es carregaran les dependències de l'aplicació React, els registres de les quals es troben al fitxer package.json. Després de descarregar les dependències a la mateixa carpeta, executeu l'ordre següent:

npm start

Això és tot. L'aplicació React s'està executant i es pot accedir navegant a l'adreça del navegador localhost:3000. Podeu canviar alguna cosa al seu codi. Veureu immediatament l'efecte d'aquests canvis al navegador. Això és possible gràcies a l'anomenada substitució "calent" dels mòduls. Gràcies a això, el desenvolupament frontal es converteix en una experiència senzilla i agradable.

▍Preparació d'una aplicació React per a la producció

Per tal d'utilitzar realment una aplicació React, hem de convertir-la en un conjunt de fitxers estàtics i servir-los als clients mitjançant un servidor web.

Per crear l'aplicació React, de nou utilitzant el terminal, navegueu a la carpeta sa-frontend i executeu l'ordre següent:

npm run build

Això crearà un directori a la carpeta del projecte build. Contindrà tots els fitxers estàtics necessaris perquè l'aplicació React funcioni.

▍Serveix fitxers estàtics amb Nginx

Primer cal instal·lar i executar el servidor web Nginx. Aquí podeu descarregar-lo i trobar instruccions per instal·lar-lo i executar-lo. Aleshores heu de copiar el contingut de la carpeta sa-frontend/build a la carpeta [your_nginx_installation_dir]/html.

Amb aquest plantejament, el fitxer generat durant el muntatge de l'aplicació React index.html estarà disponible a [your_nginx_installation_dir]/html/index.html. Aquest és el fitxer que, per defecte, emet el servidor Nginx en accedir-hi. El servidor està configurat per escoltar en un port 80, però podeu personalitzar-lo de la manera que vulgueu editant el fitxer [your_nginx_installation_dir]/conf/nginx.conf.

Ara obriu el vostre navegador i aneu a localhost:80. Veureu la pàgina de l'aplicació React.

Aplicació React servida pel servidor Nginx

Si ara introduïu alguna cosa al camp Type your sentence i premeu el botó Send - no passarà res. Però, si mireu la consola, hi podreu veure missatges d'error. Per entendre exactament on es produeixen aquests errors, analitzem el codi de l'aplicació.

▍Anàlisi del codi de l'aplicació front-end

Mirant el codi del fitxer App.js, ho podem veure fent clic al botó Send crida un mètode analyzeSentence(). El codi d'aquest mètode es mostra a continuació. Al mateix temps, presteu atenció al fet que per a cada línia a la qual hi ha un comentari del formulari # Номер, hi ha una explicació a sota del codi. De la mateixa manera, analitzarem altres fragments de codi.

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 a la qual es fa la sol·licitud POST. Se suposa que aquesta adreça és una aplicació que espera aquestes sol·licituds.

2.L'òrgan de sol·licitud enviat a l'aplicació. Aquí teniu un exemple de cos de sol·licitud:

{
    sentence: "I like yogobella!"
}

3.Quan es rep una resposta a una sol·licitud, s'actualitza l'estat del component. Això fa que el component es torni a renderitzar. Si rebem dades (és a dir, un objecte JSON que conté les dades introduïdes i la puntuació de text calculada), sortirem el component Polaritysempre que es compleixin les condicions. A continuació es descriu el component:

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

El codi sembla funcionar força bé. Què passa aquí, de totes maneres? Si suposeu que a l'adreça a la qual l'aplicació està intentant enviar una sol·licitud POST, encara no hi ha res que pugui acceptar i processar aquesta sol·licitud, aleshores tindreu tota la raó. És a dir, per tramitar les sol·licituds que arribin a l'adreça http://localhost:8080/sentiment, hem d'executar una aplicació web basada en Spring.

Necessitem una aplicació Spring que pugui acceptar una sol·licitud POST

▍Configuració d'una aplicació web basada en Spring

Per desplegar una aplicació Spring, necessiteu JDK8 i Maven i variables d'entorn configurades correctament. Després d'instal·lar tot això, podeu continuar treballant en el nostre projecte.

▍Embalatge de l'aplicació en un fitxer jar

Navegueu, mitjançant el terminal, a la carpeta sa-webapp i introduïu l'ordre següent:

mvn install

Després d'executar aquesta ordre a la carpeta sa-webapp es crearà el directori target. Aquí és on s'ubicarà l'aplicació Java, empaquetada en un fitxer jar, representat pel fitxer sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍ Llançament d'una aplicació Java

Aneu a la carpeta target i executeu l'aplicació amb l'ordre següent:

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

Es produirà un error en executar aquesta ordre. Per començar a solucionar-ho, podem analitzar els detalls de l'excepció a les dades de traça de la pila:

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}"

Per a nosaltres, el més important aquí és l'esment de la impossibilitat d'aclarir el significat sa.logic.api.url. Analitzem el codi on es produeix l'error.

▍Anàlisi del codi de l'aplicació Java

Aquí teniu el fragment de codi on es produeix l'error.

@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 hi ha un camp saLogicApiUrl. El seu valor el fixa la propietat sa.logic.api.url.
Cadena saLogicApiUrl concatena amb el valor /analyse/sentiment. Junts formen una adreça per fer una trucada al microservei que realitza l'anàlisi de text.

▍Configuració del valor d'una propietat

A Spring, la font predeterminada dels valors de propietat és un fitxer application.properties, que es pot trobar a sa-webapp/src/main/resources. Però utilitzar-lo no és l'única manera d'establir valors de propietat. També podeu fer-ho amb l'ordre següent:

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

El valor d'aquesta propietat hauria d'apuntar a l'adreça de la nostra aplicació Python.

En configurar-lo, diem a l'aplicació web Spring on ha d'anar per fer sol·licituds d'anàlisi de text.

Per no complicar-nos la vida, decidirem que l'aplicació Python estarà disponible a localhost:5000 i intenta no oblidar-ho. Com a resultat, l'ordre per iniciar l'aplicació Spring tindrà aquest aspecte:

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

Al nostre sistema li falta una aplicació Python

Ara només ens queda executar l'aplicació Python i el sistema funcionarà com s'esperava.

▍Configuració d'una aplicació Python

Per executar una aplicació Python, heu de tenir instal·lats Python 3 i Pip, i heu de tenir les variables d'entorn adequades configurades correctament.

▍Instal·lar dependències

Vés a la carpeta del projecte sa-logic/sa i executeu les ordres següents:

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

▍Inauguració de l'aplicació

Amb les dependències instal·lades, estem preparats per executar l'aplicació:

python sentiment_analysis.py

Després d'executar aquesta ordre, se'ns dirà el següent:

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

Això vol dir que l'aplicació s'està executant i esperant sol·licituds a localhost:5000/

▍Recerca de codi

Vegem el codi de l'aplicació Python per entendre com respon a les sol·licituds:

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

Inicialització d'objectes Flask.
Especificar l'adreça per fer-li les sol·licituds POST.
Recuperació d'una propietat sentence de l'òrgan de petició.
Inicialització d'objectes anònims TextBlob i obtenir el valor polarity per a la primera proposta rebuda al cos de la sol·licitud (en el nostre cas, aquesta és l'única proposta presentada per a l'anàlisi).
Devolució d'una resposta, el cos de la qual conté el text de l'oferta i l'indicador calculat per a aquesta polarity.
Llançament de l'aplicació Flask, que estarà disponible a 0.0.0.0:5000 (també podeu accedir-hi mitjançant una construcció del formulari localhost:5000).

Ara s'estan executant els microserveis que conformen l'aplicació. Estan preparats per interactuar entre ells. Aquí teniu l'aspecte del diagrama de l'aplicació en aquesta etapa del treball.

Tots els microserveis que formen l'aplicació es posen en bon estat

Ara, abans de continuar, obriu l'aplicació React en un navegador i proveu d'analitzar alguna frase amb ella. Si tot es fa correctament, després de prémer el botó Send veureu els resultats de l'anàlisi a sota del quadre de text.

A la següent secció, parlarem de com executar els nostres microserveis als contenidors Docker. Això és necessari per preparar l'aplicació per executar-se al clúster de Kubernetes.

Contenidors Docker

Kubernetes és un sistema per automatitzar el desplegament, escalat i gestió d'aplicacions en contenidors. També s'anomena "orquestrador de contenidors". Si Kubernetes treballa amb contenidors, abans d'utilitzar aquest sistema, primer hem d'adquirir aquests contenidors. Però primer, parlem de què són els contenidors. Potser es pot trobar la millor resposta a la pregunta de què és documentació a Docker:

Una imatge de contenidor és un paquet executable lleuger, autònom i que conté una aplicació, que inclou tot el necessari per executar-la: codi de l'aplicació, entorn d'execució, eines i biblioteques del sistema, configuració. Els programes en contenidors es poden utilitzar tant en entorns Linux com Windows i sempre funcionaran igual independentment de la infraestructura.

Això vol dir que els contenidors es poden executar en qualsevol ordinador, inclosos els servidors de producció, i en qualsevol entorn, les aplicacions que hi continguin funcionaran de la mateixa manera.

Per explorar les característiques dels contenidors i comparar-les amb altres maneres d'executar aplicacions, mirem l'exemple de servir una aplicació React mitjançant una màquina virtual i un contenidor.

▍Servir fitxers estàtics d'una aplicació React mitjançant una màquina virtual

En intentar organitzar el manteniment dels fitxers estàtics mitjançant màquines virtuals, ens trobarem amb els següents desavantatges:

Ús ineficient dels recursos, ja que cada màquina virtual és un sistema operatiu complet.
Dependència de la plataforma. El que funciona en algun ordinador local pot ser que no funcioni en un servidor de producció.
Escalat lenta i intensiva en recursos d'una solució de màquina virtual.

Servidor web Nginx que serveix fitxers estàtics que s'executen en una màquina virtual

Si s'utilitzen contenidors per resoldre un problema similar, en comparació amb les màquines virtuals, es poden observar els punts forts següents:

Ús eficient dels recursos: treballar amb el sistema operatiu mitjançant Docker.
Independència de la plataforma. Un contenidor que un desenvolupador pot executar al seu propi ordinador s'executarà a qualsevol lloc.
Desplegament lleuger mitjançant l'ús de capes d'imatge.

Servidor web Nginx que serveix fitxers estàtics que s'executen en un contenidor

Només hem comparat màquines virtuals i contenidors en alguns punts, però fins i tot això és suficient per tenir una idea dels punts forts dels contenidors. Aquí Podeu trobar detalls sobre els contenidors Docker.

▍Crear una imatge de contenidor per a una aplicació React

El bloc bàsic d'un contenidor Docker és el fitxer Dockerfile. Al principi d'aquest fitxer, s'enregistra una imatge base del contenidor, després s'inclou una seqüència d'instruccions que indiquen com crear un contenidor que satisfà les necessitats d'una aplicació.

Abans de començar a treballar amb el fitxer Dockerfile, recordeu què vam fer per preparar els fitxers de l'aplicació React per carregar-los al servidor Nginx:

Creació d'un paquet d'aplicació React (npm run build).
S'està iniciant el servidor Nginx.
Còpia del contingut d'un directori build de la carpeta del projecte sa-frontend a la carpeta del servidor nginx/html.

A continuació podeu veure els paral·lelismes entre la creació d'un contenidor i les accions anteriors realitzades a l'ordinador local.

▍Preparació d'un Dockerfile per a l'aplicació SA-Frontend

Instruccions a incloure Dockerfile per a la seva aplicació SA-Frontend, només consta de dues ordres. El fet és que l'equip de desenvolupament de Nginx ha preparat un element bàsic imatge per a Nginx, que utilitzarem per construir la nostra imatge. Aquests són els dos passos que hem de descriure:

Heu de fer de la imatge Nginx la base de la imatge.
Contingut de la carpeta sa-frontend/build cal copiar a la carpeta d'imatges nginx/html.

Si passem d'aquesta descripció al fitxer Dockerfile, llavors quedarà així:

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

Com podeu veure, aquí tot és molt senzill, mentre que el contingut del fitxer fins i tot resulta bastant llegible i comprensible. Aquest fitxer indica al sistema que prengui la imatge nginx amb tot el que ja té, i copiar el contingut del directori build al directori nginx/html.

Aquí podeu tenir una pregunta sobre com sé on exactament copiar els fitxers de la carpeta build, és a dir, d'on ha sortit el camí /usr/share/nginx/html. De fet, aquí tampoc no hi ha res complicat. El fet és que la informació rellevant es pot trobar a descripció imatge.

▍ Muntar la imatge i pujar-la al repositori

Abans de poder treballar amb una imatge completa, hem d'enviar-la al repositori d'imatges. Per fer-ho, utilitzarem la plataforma gratuïta d'allotjament d'imatges basada en núvol Docker Hub. En aquesta etapa del treball, heu de fer el següent:

Instal·lar estibador.
Registreu-vos al lloc de Docker Hub.
Inicieu sessió al vostre compte executant l'ordre següent al terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Ara necessiteu, mitjançant el terminal, anar al directori sa-frontend i executeu l'ordre següent allà:

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

Aquí i a continuació en ordres similars $DOCKER_USER_ID s'ha de substituir pel vostre nom d'usuari a Docker Hub. Per exemple, aquesta part de l'ordre podria semblar així: rinormaloku/sentiment-analysis-frontend.

En aquest cas, aquesta comanda es pot escurçar eliminant-la -f Dockerfile, ja que la carpeta on executem aquesta ordre ja té aquest fitxer.

Per enviar la imatge acabada al repositori, necessitem l'ordre següent:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Després de completar-lo, comproveu la vostra llista de dipòsits a Docker Hub per veure si la imatge s'ha enviat correctament a l'emmagatzematge al núvol.

▍Engegar un contenidor

Ara qualsevol pot descarregar i executar la imatge coneguda com a $DOCKER_USER_ID/sentiment-analysis-frontend. Per fer-ho, heu d'executar la següent seqüència d'ordres:

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

Ara el contenidor s'està executant i podem continuar treballant creant altres imatges que necessitem. Però abans de continuar, entenem el disseny 80:80, que es troba a l'ordre per executar la imatge i pot semblar confús.

Primer número 80 és el número de port de l'amfitrió (és a dir, l'ordinador local).
Segon número 80 és el port del contenidor al qual s'ha de redirigir la sol·licitud.

Considereu la il·lustració següent.

Reenviament de ports

El sistema reenvia les peticions des del port <hostPort> al port <containerPort>. És a dir, accedir al port 80 l'ordinador es redirigeix a un port 80 contenidor.

Des del port 80 obert a l'ordinador local, podeu accedir a l'aplicació des d'aquest ordinador a localhost:80. Si el vostre sistema no és compatible amb Docker, podeu executar l'aplicació en una màquina virtual Docker, l'adreça de la qual es veurà com <docker-machine ip>:80. Per esbrinar l'adreça IP de la màquina virtual Docker, podeu utilitzar l'ordre docker-machine ip.

En aquest punt, un cop el contenidor d'aplicacions frontal s'hagi llançat correctament, hauríeu de poder obrir la seva pàgina en un navegador.

▍.dockerignore fitxer

Construcció de la imatge de l'aplicació SA-Frontend, podríem notar que aquest procés és extremadament lent. Això es deu al fet que el context de creació de la imatge s'ha d'enviar al dimoni Docker. El directori que representa el context de compilació es dóna com a darrer argument de l'ordre docker build. En el nostre cas, hi ha un punt al final d'aquesta ordre. Això fa que s'inclogui l'estructura següent en el context del muntatge:

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

Però de totes les carpetes que hi ha aquí, només necessitem una carpeta build. Descarregar qualsevol altra cosa és una pèrdua de temps. Podeu accelerar la compilació dient a Docker quins directoris ignorar. Per fer-ho, necessitem un fitxer .dockerignore. Tu, si estàs familiaritzat amb el fitxer .gitignore, l'estructura d'aquest fitxer probablement sembli familiar. Llista els directoris que el sistema de creació d'imatges pot ignorar. En el nostre cas, el contingut d'aquest fitxer té aquest aspecte:

node_modules
src
public

expedient .dockerignore ha d'estar a la mateixa carpeta que el fitxer Dockerfile. Ara el muntatge de la imatge trigarà uns segons.

Tractem ara la imatge d'una aplicació Java.

▍Crear una imatge de contenidor per a una aplicació Java

Ja sabeu què, i ja heu après tot el que necessiteu per crear imatges de contenidors. Per això aquest apartat serà molt breu.

Obriu el fitxer Dockerfile, que es troba a la carpeta del projecte sa-webapp. Si llegiu el text d'aquest fitxer, només hi trobareu dues construccions noves que comencen amb paraules clau ENV и EXPOSE:

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

Paraula clau ENV us permet declarar variables d'entorn dins dels contenidors Docker. En concret, en el nostre cas, permet establir una URL per accedir a l'API de l'aplicació que realitza l'anàlisi de text.

Paraula clau EXPOSE us permet dir a Docker que obri un port. Utilitzarem aquest port mentre treballem amb l'aplicació. Aquí ho podeu veure a Dockerfile per a la seva aplicació SA-Frontend no hi ha tal comandament. Això només té finalitats de documentació, és a dir, aquesta construcció és per al lector Dockerfile.

La creació de la imatge i l'empènyer al repositori és exactament com l'exemple anterior. Si encara no tens molta confiança en les teves habilitats, pots trobar les ordres corresponents al fitxer README.md a la carpeta sa-webapp.

▍Crear una imatge de contenidor per a una aplicació Python

Si mireu el contingut del fitxer Dockerfile a la carpeta sa-logicno hi trobareu res de nou. Les ordres per crear la imatge i enviar-la al repositori ja us haurien de ser familiars, però, com en el cas de les nostres altres aplicacions, les podeu trobar al fitxer README.md a la carpeta sa-logic.

▍Prova d'aplicacions en contenidors

Pots confiar en alguna cosa que no has provat? Jo tampoc puc. Anem a provar els nostres contenidors.

Comencem el contenidor de l'aplicació sa-logic i configurar-lo per escoltar-lo en un port 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Comencem el contenidor de l'aplicació sa-webapp i configurar-lo per escoltar-lo en un port 8080. A més, hem d'establir el port on l'aplicació Python escoltarà les sol·licituds de l'aplicació Java reassignant la variable d'entorn. 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
```

Per saber com esbrinar l'adreça IP d'un contenidor o d'una màquina virtual de Docker, consulteu el fitxer README.

Comencem el contenidor de l'aplicació sa-frontend:

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

Ara tot està preparat per navegar al navegador fins a l'adreça localhost:80 i prova l'aplicació.

Tingueu en compte que si canvieu el port per sa-webapp, o si esteu executant una màquina virtual de Docker, haureu d'editar el fitxer App.js de la carpeta sa-frontendcanviant l'adreça IP o el número de port al mètode analyzeSentence()substituint la informació actual en lloc de dades obsoletes. Després d'això, heu de tornar a muntar la imatge i utilitzar-la.

Aquest és el que sembla ara el nostre diagrama d'aplicació.

Els microserveis s'executen en contenidors

Resum: per què necessitem un clúster de Kubernetes?

Acabem de revisar els fitxers Dockerfile, va parlar sobre com crear imatges i enviar-les a un repositori de Docker. A més, vam aprendre a accelerar el muntatge d'imatges mitjançant el fitxer .dockerignore. Com a resultat, els nostres microserveis ara s'executen als contenidors Docker. Aquí podeu tenir una pregunta completament justificada sobre per què necessitem Kubernetes. La resposta a aquesta pregunta es dedicarà a la segona part d'aquest material. Mentrestant, considereu la pregunta següent:
Suposem que la nostra aplicació web d'anàlisi de text s'ha fet popular a tot el món. Milions de peticions li arriben cada minut. Això vol dir que els microserveis sa-webapp и sa-logic estarà sota un estrès enorme. Com escalar els contenidors que executen microserveis?

Font: www.habr.com

Tutorial de Kubernetes Part 1: aplicacions, microserveis i contenidors