🥇Tutorial Kubernetes Parte 1: Aplicacións, microservizos e contedores

A nosa petición, Habr creou un hub Kubernetes e temos o pracer de colocar nela a primeira publicación. Subscríbete!

Kubernetes é doado. Por que os bancos me pagan moitos cartos por traballar nesta área, mentres calquera pode dominar esta tecnoloxía en poucas horas?

Se dubidas de que Kubernetes se poida aprender tan rápido, suxíroche que intentes facelo por ti mesmo. É dicir, unha vez dominado este material, poderás executar unha aplicación baseada en microservizos nun clúster de Kubernetes. Podo garantilo, porque é na mesma metodoloxía que eu uso aquí onde ensino aos nosos clientes a traballar con Kubernetes. Que fai que esta guía sexa diferente das outras? En realidade, moitas cousas. Entón, a maioría destes materiais comezan cunha explicación de cousas sinxelas: os conceptos de Kubernetes e as características do comando kubectl. Os autores destes artigos asumen que o seu lector está familiarizado co desenvolvemento de aplicacións, os microservizos e os contedores Docker. Iremos por outro lado. En primeiro lugar, imos falar sobre como executar unha aplicación baseada en microservizos nun ordenador. Despois analizaremos a creación de imaxes de contedores para cada microservizo. E despois diso, familiarizarémonos con Kubernetes e analizaremos a implantación dunha aplicación baseada en microservizos nun clúster xestionado por Kubernetes.

Este enfoque, cunha aproximación gradual a Kubernetes, proporcionará a profundidade de comprensión do que está a suceder que a persoa media necesita para comprender como todo está organizado en Kubernetes. Kubernetes é sen dúbida unha tecnoloxía sinxela, sempre que quen queira dominala saiba onde e como se usa.

Agora, sen máis, poñémonos mans á obra e falemos da aplicación coa que traballaremos.

Aplicación experimental

A nosa aplicación só realizará unha función. Toma, como entrada, unha frase, tras a cal, utilizando ferramentas de análise de textos, realiza unha análise de sentimentos desta frase, obtendo unha valoración da actitude emocional do autor da frase ante un determinado obxecto.

Este é o aspecto da xanela principal desta aplicación.

Aplicación web de análise de sentimentos

Desde o punto de vista técnico, a aplicación consta de tres microservizos, cada un dos cales resolve un determinado conxunto de tarefas:

SA-Frontend é un servidor web de Nginx que serve ficheiros estáticos de React.
SA-WebApp é unha aplicación web escrita en Java que xestiona as solicitudes do frontend.
SA-Logic é unha aplicación de Python que realiza análise de sentimentos de texto.

É importante ter en conta que os microservizos non existen de forma illada. Implementan a idea de "separación de funcións", pero, ao mesmo tempo, necesitan interactuar entre si.

Fluxos de datos na aplicación

No diagrama anterior, podes ver as etapas numeradas do sistema, ilustrando os fluxos de datos na aplicación. Desglosámolos:

O navegador solicita un ficheiro ao servidor index.html (que á súa vez carga o paquete da aplicación React).
O usuario interactúa coa aplicación, isto provoca unha chamada a unha aplicación web baseada en Spring.
A aplicación web envía a solicitude para analizar o texto á aplicación Python.
A aplicación Python analiza o sentimento do texto e devolve o resultado como resposta á solicitude.
A aplicación Spring envía unha resposta á aplicación React (que, á súa vez, mostra o resultado do texto analizado ao usuario).

Pódese atopar o código de todas estas aplicacións aquí. Recomendo que copies este repositorio agora mesmo, xa que hai moitos experimentos interesantes con el por diante.

Execución dunha aplicación baseada en microservizos na máquina local

Para que a aplicación funcione, necesitamos iniciar os tres microservizos. Comecemos polo máis bonito deles: a aplicación front-end.

▍Configuración de React para o desenvolvemento local

Para executar unha aplicación React, cómpre instalar o framework Node.js e o NPM no seu ordenador. Despois de instalar todo isto, vai usando o terminal ao cartafol do proxecto sa-frontend e executa o seguinte comando:

npm install

Ao executar este comando no cartafol node_modules cargaranse as dependencias da aplicación React, cuxos rexistros están no ficheiro package.json. Despois de descargar as dependencias no mesmo cartafol, execute o seguinte comando:

npm start

Iso é todo. A aplicación React está agora en execución e pódese acceder navegando ata o enderezo do navegador localhost:3000. Podes cambiar algo no seu código. Verá inmediatamente o efecto destes cambios no navegador. Isto é posible grazas á chamada substitución "en quente" de módulos. Grazas a isto, o desenvolvemento front-end convértese nunha experiencia sinxela e agradable.

▍Preparación dunha aplicación React para a produción

Para os efectos de usar realmente unha aplicación React, necesitamos convertela nun conxunto de ficheiros estáticos e servilos aos clientes mediante un servidor web.

Para crear a aplicación React, de novo usando o terminal, navegue ata o cartafol sa-frontend e executa o seguinte comando:

npm run build

Isto creará un directorio no cartafol do proxecto build. Conterá todos os ficheiros estáticos necesarios para que funcione a aplicación React.

▍Servizo ficheiros estáticos con Nginx

Primeiro cómpre instalar e executar o servidor web Nginx. Aquí podes descargalo e atopar instrucións para instalalo e executalo. A continuación, cómpre copiar o contido do cartafol sa-frontend/build á carpeta [your_nginx_installation_dir]/html.

Con este enfoque, o ficheiro xerado durante a montaxe da aplicación React index.html estará dispoñible en [your_nginx_installation_dir]/html/index.html. Este é o ficheiro que, por defecto, emite o servidor Nginx ao acceder a el. O servidor está configurado para escoitar nun porto 80, pero podes personalizalo do xeito que queiras editando o ficheiro [your_nginx_installation_dir]/conf/nginx.conf.

Agora abre o teu navegador e vai a localhost:80. Verás a páxina da aplicación React.

Aplicación React servida polo servidor Nginx

Se agora introduce algo no campo Type your sentence e prema o botón Send - non pasará nada. Pero, se miras a consola, podes ver mensaxes de erro alí. Para comprender exactamente onde ocorren estes erros, analicemos o código da aplicación.

▍Análise do código da aplicación front-end

Mirando o código do ficheiro App.js, podemos ver que premendo no botón Send chama un método analyzeSentence(). O código deste método móstrase a continuación. Ao mesmo tempo, preste atención ao feito de que para cada liña á que hai un comentario do formulario # Номер, hai unha explicación debaixo do código. Do mesmo xeito, analizaremos outros fragmentos de código.

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. O URL ao que se fai a solicitude POST. Suponse que este enderezo é unha aplicación á espera de tales solicitudes.

2.O órgano de solicitude enviado á solicitude. Aquí tes un exemplo de corpo de solicitude:

{
    sentence: "I like yogobella!"
}

3.Cando se recibe unha resposta a unha solicitude, actualízase o estado do compoñente. Isto fai que o compoñente volva renderizarse. Se recibimos datos (é dicir, un obxecto JSON que contén os datos introducidos e a puntuación de texto calculada), sairemos o compoñente Polaritysempre que se cumpran as condicións. Aquí é como describimos o compoñente:

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

O código parece funcionar bastante ben. Que pasa aquí, de todos os xeitos? Se asume que no enderezo ao que a aplicación está tentando enviar unha solicitude POST, aínda non hai nada que poida aceptar e procesar esta solicitude, terás toda a razón. É dicir, para tramitar as solicitudes que chegan ao enderezo http://localhost:8080/sentiment, necesitamos executar unha aplicación web baseada en Spring.

Necesitamos unha aplicación Spring que poida aceptar unha solicitude POST

▍Configuración dunha aplicación web baseada en Spring

Para implementar unha aplicación Spring, necesitas JDK8 e Maven e variables de ambiente configuradas correctamente. Despois de instalar todo isto, podes seguir traballando no noso proxecto.

▍Embalaxe da aplicación nun ficheiro jar

Navega, usando o terminal, ata o cartafol sa-webapp e introduza o seguinte comando:

mvn install

Despois de executar este comando no cartafol sa-webapp crearase o directorio target. Aquí é onde se localizará a aplicación Java, empaquetada nun ficheiro jar, representado polo ficheiro sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Lanzamento dunha aplicación Java

Ir ao cartafol target e executa a aplicación co seguinte comando:

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

Producirase un erro ao executar este comando. Para comezar a solucionalo, podemos analizar os detalles da excepción nos datos de rastrexo da 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}"

Para nós, o máis importante aquí é a mención á imposibilidade de aclarar o significado sa.logic.api.url. Analizemos o código onde se produce o erro.

▍Análise do código da aplicación Java

Aquí está o fragmento de código onde se produce o erro.

@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 hai un campo saLogicApiUrl. O seu valor está establecido pola propiedade sa.logic.api.url.
Liña saLogicApiUrl concatena co valor /analyse/sentiment. Xuntos forman un enderezo para facer unha chamada ao microservizo que realiza a análise de texto.

▍Establecer o valor dunha propiedade

En Spring, a fonte predeterminada dos valores de propiedade é un ficheiro application.properties, que se pode atopar en sa-webapp/src/main/resources. Pero usalo non é o único xeito de establecer os valores das propiedades. Tamén podes facelo co seguinte comando:

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

O valor desta propiedade debería apuntar ao enderezo da nosa aplicación Python.

Ao configuralo, dicímoslle á aplicación web Spring onde ten que ir para executar solicitudes de análise de texto.

Para non complicarnos a vida, decidiremos que a aplicación Python estará dispoñible en localhost:5000 e intenta non esquecerlo. Como resultado, o comando para iniciar a aplicación Spring terá o seguinte aspecto:

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

Falta unha aplicación Python ao noso sistema

Agora só temos que executar a aplicación Python e o sistema funcionará como se esperaba.

▍Configuración dunha aplicación Python

Para executar unha aplicación Python, debes ter instalados Python 3 e Pip, e debes ter as variables de ambiente adecuadas configuradas correctamente.

▍Instalar dependencias

Vaia ao cartafol do proxecto sa-logic/sa e executa os seguintes comandos:

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

▍Lanzamento da aplicación

Coas dependencias instaladas, estamos preparados para executar a aplicación:

python sentiment_analysis.py

Despois de executar este comando, dirémosnos o seguinte:

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

Isto significa que a aplicación está en execución e agardando solicitudes en localhost:5000/

▍ Investigación de códigos

Vexamos o código da aplicación Python para comprender como responde ás solicitudes:

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

Inicialización de obxectos Flask.
Especificando o enderezo para facerlle solicitudes POST.
Recuperación dunha propiedade sentence do órgano de solicitude.
Inicialización de obxectos anónimos TextBlob e obtendo o valor polarity para a primeira proposta recibida no corpo da solicitude (no noso caso, esta é a única proposta sometida a análise).
Devolver unha resposta, cuxo corpo contén o texto da oferta e o indicador calculado para ela polarity.
Lanzamento da aplicación Flask, que estará dispoñible en 0.0.0.0:5000 (tamén pode acceder a el mediante unha construción do formulario localhost:5000).

Agora están a executarse os microservizos que compoñen a aplicación. Están configurados para interactuar entre si. Aquí está o aspecto do diagrama da aplicación nesta fase de traballo.

Todos os microservizos que compoñen a aplicación pasan a un estado saudable

Agora, antes de continuar, abra a aplicación React nun navegador e intente analizar algunha frase con ela. Se todo está feito correctamente - despois de premer o botón Send verá os resultados da análise debaixo do cadro de texto.

Na seguinte sección, falaremos de como executar os nosos microservizos en contedores Docker. Isto é necesario para preparar a aplicación para executarse no clúster de Kubernetes.

Contenedores Docker

Kubernetes é un sistema para automatizar o despregamento, escalado e xestión de aplicacións contenedoras. Tamén se lle chama "orquestrador de contedores". Se Kubernetes traballa con contedores, antes de usar este sistema, primeiro necesitamos adquirir estes contedores. Pero primeiro, imos falar do que son os contedores. Quizais a mellor resposta á pregunta de que é pódese atopar documentación a Docker:

Unha imaxe de contedor é un paquete executable lixeiro e autónomo que contén unha aplicación, que inclúe todo o necesario para executala: código da aplicación, ambiente de execución, ferramentas e bibliotecas do sistema, configuración. Os programas en contedores pódense usar tanto en ambientes Linux como Windows e sempre funcionarán igual independentemente da infraestrutura.

Isto significa que os contedores poden executarse en calquera ordenador, incluídos os servidores de produción, e en calquera ambiente, as aplicacións que se inclúen neles funcionarán do mesmo xeito.

Para explorar as funcións dos contedores e comparalas con outras formas de executar aplicacións, vexamos o exemplo de servir unha aplicación React mediante unha máquina virtual e un contedor.

▍Servizo de ficheiros estáticos dunha aplicación React mediante unha máquina virtual

Tentando organizar o mantemento de ficheiros estáticos mediante máquinas virtuais, atoparémonos coas seguintes desvantaxes:

Uso ineficiente dos recursos, xa que cada máquina virtual é un sistema operativo completo.
Dependencia da plataforma. O que funciona nalgún ordenador local pode non funcionar nun servidor de produción.
Escalado lento e intensivo de recursos dunha solución de máquina virtual.

Servidor web Nginx que serve ficheiros estáticos que se executan nunha máquina virtual

Se se usan contedores para resolver un problema similar, en comparación coas máquinas virtuais, pódense observar os seguintes puntos fortes:

Uso eficiente dos recursos: traballar co sistema operativo mediante Docker.
Independencia da plataforma. Un contedor que un desenvolvedor pode executar no seu propio ordenador executarase en calquera lugar.
Implementación lixeira mediante o uso de capas de imaxe.

Servidor web Nginx que serve ficheiros estáticos que se executan nun contedor

Só comparamos máquinas virtuais e contedores en algúns puntos, pero aínda iso é suficiente para coñecer os puntos fortes dos contedores. Aquí Podes atopar detalles sobre os contedores Docker.

▍Creación dunha imaxe de contedor para unha aplicación React

O bloque básico dun contedor Docker é o ficheiro Dockerfile. Ao comezo deste ficheiro, grávase unha imaxe base do contedor, despois inclúese unha secuencia de instrucións que indica como crear un contedor que satisfaga as necesidades dunha aplicación.

Antes de comezar a traballar co ficheiro Dockerfile, lembra o que fixemos para preparar os ficheiros da aplicación React para cargalos no servidor Nginx:

Creando un paquete de aplicación React (npm run build).
Iniciando o servidor Nginx.
Copiando o contido dun directorio build dende o cartafol do proxecto sa-frontend ao cartafol do servidor nginx/html.

A continuación podes ver os paralelismos entre a creación dun contedor e as accións anteriores realizadas no ordenador local.

▍Preparación dun Dockerfile para a aplicación SA-Frontend

Instrucións para incluír Dockerfile para aplicación SA-Frontend, composto só por dous equipos. O caso é que o equipo de desenvolvemento de Nginx preparou un básico imaxe para Nginx, que utilizaremos para construír a nosa imaxe. Aquí están os dous pasos que debemos describir:

Debes facer que a imaxe de Nginx sexa a base da imaxe.
Contido do cartafol sa-frontend/build cómpre copialo no cartafol de imaxes nginx/html.

Se pasamos desta descrición ao ficheiro Dockerfile, entón quedará así:

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

Como podes ver, aquí todo é moi sinxelo, aínda que o contido do ficheiro incluso resulta bastante lexible e comprensible. Este ficheiro indica ao sistema que tome a imaxe nginx con todo o que xa ten, e copia o contido do directorio build ao directorio nginx/html.

Aquí podes ter unha pregunta sobre como sei onde copiar exactamente os ficheiros do cartafol build, é dicir, de onde veu o camiño /usr/share/nginx/html. De feito, aquí tampouco hai nada complicado. O caso é que a información relevante pódese atopar en descrición imaxe.

▍Ensamblar a imaxe e cargala ao repositorio

Antes de poder traballar cunha imaxe completa, necesitamos enviala ao repositorio de imaxes. Para iso, utilizaremos a plataforma gratuíta de hospedaxe de imaxes baseada na nube Docker Hub. Nesta fase do traballo, cómpre facer o seguinte:

Instala Estivador.
Rexístrese no sitio de Docker Hub.
Inicie sesión na súa conta executando o seguinte comando no terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Agora necesitas, usando o terminal, ir ao directorio sa-frontend e executa o seguinte comando alí:

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

Aquí e abaixo en comandos similares $DOCKER_USER_ID debe substituírse polo seu nome de usuario en Docker Hub. Por exemplo, esta parte do comando pode verse así: rinormaloku/sentiment-analysis-frontend.

Neste caso, este comando pódese acurtar quitándoo -f Dockerfile, xa que o cartafol no que executamos este comando xa ten este ficheiro.

Para enviar a imaxe rematada ao repositorio, necesitamos o seguinte comando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Despois de completalo, verifique a súa lista de repositorios en Docker Hub para ver se a imaxe foi enviada correctamente ao almacenamento na nube.

▍Iniciando un recipiente

Agora calquera pode descargar e executar a imaxe coñecida como $DOCKER_USER_ID/sentiment-analysis-frontend. Para facelo, cómpre executar a seguinte secuencia de comandos:

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

Agora o contedor está a funcionar e podemos seguir traballando creando outras imaxes que necesitemos. Pero antes de continuar, entendamos o deseño 80:80, que se atopa no comando para executar a imaxe e pode parecer confuso.

Primeiro número 80 é o número de porto do host (é dicir, o ordenador local).
Segundo número 80 é o porto do contedor ao que se debe redirixir a solicitude.

Considere a seguinte ilustración.

Reenvío de portos

O sistema reenvía as solicitudes do porto <hostPort> ao porto <containerPort>. É dicir, acceder ao porto 80 o ordenador é redirixido a un porto 80 envase.

Dende o porto 80 aberto no ordenador local, pode acceder á aplicación desde este ordenador en localhost:80. Se o teu sistema non é compatible con Docker, podes executar a aplicación nunha máquina virtual Docker, cuxo enderezo será como <docker-machine ip>:80. Para coñecer o enderezo IP da máquina virtual Docker, pode usar o comando docker-machine ip.

Neste punto, unha vez que o contedor de aplicacións front-end se lanzou con éxito, deberías poder abrir a súa páxina nun navegador.

▍.dockerignore ficheiro

Construción da imaxe da aplicación SA-Frontend, puidemos notar que este proceso é extremadamente lento. Isto débese a que o contexto de construción da imaxe debe enviarse ao daemon Docker. O directorio que representa o contexto de compilación dáse como último argumento para o comando docker build. No noso caso, hai un punto ao final deste comando. Isto fai que a seguinte estrutura se inclúa no contexto da asemblea:

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

Pero de todos os cartafoles presentes aquí, só necesitamos un cartafol build. Descargar calquera outra cousa é unha perda de tempo. Podes acelerar a compilación indicando a Docker que directorios ignora. Para facelo, necesitamos un ficheiro .dockerignore. Ti, se estás familiarizado co ficheiro .gitignore, a estrutura deste ficheiro probablemente parecerá familiar. Lista os directorios que o sistema de creación de imaxes pode ignorar. No noso caso, o contido deste ficheiro ten o seguinte aspecto:

node_modules
src
public

arquivo .dockerignore debe estar no mesmo cartafol que o ficheiro Dockerfile. Agora a montaxe da imaxe levará uns segundos.

Imos agora tratar a imaxe para unha aplicación Java.

▍Creación dunha imaxe de contedor para unha aplicación Java

Xa sabes que, e xa aprendeches todo o que necesitas para crear imaxes de contedores. Por iso esta sección será moi curta.

Abre o ficheiro Dockerfile, que se atopa no cartafol do proxecto sa-webapp. Se le o texto deste ficheiro, nel coñecerá só dúas novas construcións que comezan con palabras clave ENV и EXPOSE:

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

Palabra clave ENV permítelle declarar variables de ambiente dentro dos contedores Docker. En particular, no noso caso, permítelle establecer un URL para acceder á API da aplicación que realiza a análise de texto.

Palabra clave EXPOSE permítelle dicir a Docker que abra o porto. Imos utilizar este porto mentres traballamos coa aplicación. Aquí podes velo en Dockerfile para aplicación SA-Frontend non existe tal comando. Isto é só para fins de documentación, noutras palabras, esta construción é para o lector Dockerfile.

Construír a imaxe e empuxala ao repositorio parece exactamente igual ao exemplo anterior. Se aínda non tes moita confianza nas túas habilidades, podes atopar os comandos correspondentes no ficheiro README.md no cartafol sa-webapp.

▍Creación dunha imaxe de contedor para unha aplicación Python

Se botas un ollo ao contido do ficheiro Dockerfile no cartafol sa-logicnon atoparás nada novo alí. Os comandos para construír a imaxe e enviala ao repositorio xa deberían serlle familiares, pero, como no caso das nosas outras aplicacións, pódense atopar no ficheiro README.md no cartafol sa-logic.

▍Proba de aplicacións en contedores

Podes confiar en algo que non probaches? Eu tampouco podo. Probamos os nosos envases.

Imos comezar o contedor da aplicación sa-logic e configúrao para escoitar nun porto 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Imos comezar o contedor da aplicación sa-webapp e configúrao para escoitar nun porto 8080. Ademais, necesitamos establecer o porto no que a aplicación Python escoitará as solicitudes da aplicación Java reasignando a variable de ambiente 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
```

Para saber como descubrir o enderezo IP dun contedor ou dunha máquina virtual Docker, consulte o ficheiro README.

Imos comezar o contedor da aplicación sa-frontend:

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

Agora todo está listo para navegar no navegador ata o enderezo localhost:80 e proba a aplicación.

Teña en conta que se cambia o porto para sa-webapp, ou se estás executando unha máquina virtual Docker, terás que editar o ficheiro App.js do cartafol sa-frontendcambiando o enderezo IP ou o número de porto no método analyzeSentence()substituíndo información actual en lugar de datos obsoletos. Despois diso, cómpre volver montar a imaxe e usala.

Este é o noso diagrama de aplicacións agora.

Os microservizos execútanse en contedores

Resumo: por que necesitamos un clúster de Kubernetes?

Acabamos de revisar os ficheiros Dockerfile, falou sobre como construír imaxes e envialas a un repositorio de Docker. Ademais, aprendemos a acelerar a montaxe de imaxes mediante o ficheiro .dockerignore. Como resultado, os nosos microservizos agora están a executarse en contedores Docker. Aquí podes ter unha pregunta completamente xustificada sobre por que necesitamos Kubernetes. A resposta a esta pregunta dedicarase á segunda parte deste material. Mentres tanto, considere a seguinte pregunta:
Supoñamos que a nosa aplicación web de análise de textos fíxose popular en todo o mundo. Millóns de peticións chegan a el cada minuto. Isto significa que os microservizos sa-webapp и sa-logic estará sometido a un estrés enorme. Como escalar os contedores que executan microservizos?

Fonte: www.habr.com

Titorial de Kubernetes Parte 1: aplicacións, microservizos e contedores