🥇Guía de Kubernetes, parte 1: aplicaciones, microservicios y contenedores

A petición nuestra, Habr ha creado un hub Kubernetes y nos complace publicar la primera publicación en él. ¡Suscríbete!

Kubernetes es simple. Entonces, ¿por qué los bancos me pagan tanto por trabajar en este campo, mientras que cualquier persona puede dominar esta tecnología en pocas horas?

Si dudas que se puede aprender Kubernetes tan rápido, te propongo intentarlo tú mismo. Al dominar este material, podrás lanzar una aplicación basada en microservicios en un clúster de Kubernetes. Puedo garantizarlo, ya que fue esta metodología que utilizo aquí para enseñar a nuestros clientes sobre Kubernetes. ¿Qué diferencia a esta guía de otras? En realidad, mucho. La mayoría de estos materiales comienzan explicando cosas simples: conceptos de Kubernetes y características del comando kubectl. Los autores de estos materiales suponen que su lector está familiarizado con el desarrollo de aplicaciones, microservicios y contenedores Docker. Pero nosotros tomaremos otro camino. Primero, hablaremos sobre cómo ejecutar una aplicación basada en microservicios en tu computadora. Luego, consideraremos la construcción de imágenes de contenedores para cada microservicio. Y solo después de eso, nos familiarizaremos con Kubernetes y haremos el despliegue de la aplicación basada en microservicios en un clúster gestionado por Kubernetes.

Este enfoque, acercándose a Kubernetes gradualmente, dará la profundidad de comprensión necesaria para que una persona común entienda lo simple que es Kubernetes. Kubernetes es, sin duda, una tecnología sencilla, siempre que quien quiera aprenderla sepa dónde y cómo se utiliza.

Ahora, sin más preámbulos, comencemos a trabajar y hablemos de la aplicación con la que vamos a trabajar.

Aplicación experimental

Nuestra aplicación solo realizará una función. Acepta, como entrada, una frase, y luego, utilizando herramientas de análisis de texto, realiza un análisis de sentimiento de esa frase, obteniendo una evaluación de la relación emocional del autor de la frase hacia un objeto particular.

Así es como se ve la ventana principal de esta aplicación.

Aplicación web para análisis de sentimiento de textos

Desde un punto de vista técnico, la aplicación consiste en tres microservicios, cada uno de los cuales resuelve un conjunto específico de tareas:

SA-Frontend es un servidor web Nginx que atiende archivos estáticos de React.
SA-WebApp es una aplicación web escrita en Java que maneja las solicitudes del frontend.
SA-Logic es una aplicación en Python que realiza análisis de sentimiento del texto.

Es importante mencionar que los microservicios no existen en aislamiento. Implementan la idea de "división de responsabilidades", pero necesitan interactuar entre sí.

Flujos de datos en la aplicación

En el esquema anterior, se pueden ver las etapas numeradas del trabajo del sistema, ilustrando los flujos de datos en la aplicación. Analicemos cada una:

El navegador solicita un archivo al servidor index.html (que, a su vez, carga el paquete de la aplicación React).
El usuario interactúa con la aplicación, lo que genera una solicitud a la aplicación web basada en Spring.
La aplicación web redirige la solicitud para realizar el análisis de texto a la aplicación Python.
La aplicación Python realiza el análisis de sentimiento del texto y devuelve el resultado como respuesta a la solicitud.
La aplicación de Spring envía la respuesta a la aplicación React (y esta, a su vez, muestra el resultado del análisis de texto al usuario).

El código para todas estas aplicaciones se puede encontrar aquí. Te recomiendo que copies este repositorio ahora mismo, ya que nos esperan muchos experimentos interesantes con él.

Ejecución de una aplicación basada en microservicios en la computadora local

Para que la aplicación funcione, necesitamos iniciar los tres microservicios. Empezaremos con el más atractivo de ellos: la aplicación frontend.

▍Configuración de React para desarrollo local

Para ejecutar la aplicación React, debes instalar Node.js y NPM en tu computadora. Una vez que hayas instalado todo esto, usa la terminal para navegar a la carpeta del proyecto sa-frontend y ejecuta el siguiente comando:

npm install

Al ejecutar este comando, las dependencias de la aplicación React se cargarán en la carpeta node_modules , cuyos registros se encuentran en el archivo package.json. Después de que se completen la carga de dependencias, ejecuta el siguiente comando en la misma carpeta:

npm start

Y eso es todo. Ahora la aplicación React está en funcionamiento, y puedes acceder a ella en el navegador en la dirección localhost:3000. Puedes cambiar algo en su código. El efecto de estos cambios lo verás inmediatamente en el navegador. Esto es posible gracias a lo que se conoce como 'reemplazo en caliente' de módulos. Gracias a esto, el desarrollo frontend se convierte en una actividad sencilla y agradable.

▍Preparación de la aplicación React para lanzarla a producción

Para el uso real de una aplicación React, necesitamos convertirla en un conjunto de archivos estáticos y entregarles a los clientes utilizando un servidor web.

Para construir la aplicación React, nuevamente, usando la terminal, dirígete a la carpeta sa-frontend y ejecuta el siguiente comando:

npm run build

Esto llevará a la creación de un directorio en la carpeta del proyecto build. En ella se contendrán todos los archivos estáticos necesarios para el funcionamiento de la aplicación React.

▍Mantenimiento de archivos estáticos con Nginx

Primero, necesitas instalar y ejecutar el servidor web Nginx. Aquí Puedes descargarlo y encontrar instrucciones para la instalación y ejecución. Luego, necesitas copiar el contenido de la carpeta sa-frontend/build a la carpeta [your_nginx_installation_dir]/html.

Con este enfoque, el archivo generado en el proceso de construcción de la aplicación React index.html estará disponible en la dirección [your_nginx_installation_dir]/html/index.html. Este es el archivo que, por defecto, el servidor Nginx presenta al ser accedido. El servidor está configurado para escuchar el puerto 80, pero se puede configurar según tus necesidades editando el archivo [your_nginx_installation_dir]/conf/nginx.conf.

Ahora abre el navegador y accede a la dirección localhost:80. Verás la página de la aplicación React.

Aplicación React servida por el servidor Nginx

Si ahora introduces algo en el campo Type your sentence y presionas el botón Send — no sucederá nada. Pero, si miras en la consola, puedes ver mensajes de error. Para entender dónde ocurren exactamente estos errores, analizaremos el código de la aplicación.

▍Análisis del código de la aplicación frontend

Al observar el código del archivo App.js, podemos ver que al presionar el botón Send se llama al método analyzeSentence(). El código de este método se proporciona a continuación. Ten en cuenta que a cada línea que tiene un comentario del tipo # Номер, hay una explicación dada debajo del código. De la misma manera, iremos analizando otros fragmentos del 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. URL en la que se realiza la solicitud POST. Se supone que en esta dirección hay una aplicación que está esperando tales solicitudes.

2.Cuerpo de la solicitud que se envía a la aplicación. Aquí hay un ejemplo del cuerpo de la solicitud:

{
    sentence: "¡Me gusta yogobella!"
}

3.Al recibir la respuesta a la solicitud, se actualiza el estado del componente. Esto provoca un nuevo renderizado del componente. Si obtenemos datos (es decir, un objeto JSON que contiene los datos ingresados y la evaluación calculada del texto), mostraremos el componente Polaridad, ya que se cumplirán las condiciones correspondientes. Así es como describimos el componente:

const polarityComponent = this.state.polarity !== undefined ?
     :
    null;

El código parece funcionar correctamente. ¿Qué podría estar mal aquí? Si suponemos que en la dirección a la que la aplicación intenta enviar la solicitud POST no hay nada que pueda aceptar y procesar esa solicitud, tienes toda la razón. En particular, para manejar las solicitudes que llegan a la dirección http://localhost:8080/sentiment, necesitamos ejecutar una aplicación web basada en Spring.

Necesitamos una aplicación de Spring capaz de aceptar la solicitud POST

▍Configuración de una aplicación web basada en Spring

Para desplegar una aplicación de Spring, necesitarás JDK8 y Maven, y variables de entorno correctamente configuradas. Después de instalar todo esto, puedes continuar trabajando en nuestro proyecto.

▍Empaquetado de la aplicación en un archivo jar

Navega, usando la terminal, a la carpeta sa-webapp y escribe el siguiente comando:

mvn install

Después de ejecutar este comando, se creará un directorio en la carpeta sa-webapp . Aquí estará la aplicación Java empaquetada en un archivo jar, que está representada por el archivo targetsentiment-analysis-web-0.0.1-SNAPSHOT.jar ▍Ejecutando la aplicación Java.

Navega a la carpeta

y ejecuta la aplicación con el siguiente comando: target java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

Al ejecutar este comando, ocurrirá un error. Para comenzar a solucionarlo, podemos analizar la información sobre la excepción en los datos de la traza del stack:

Al ejecutar este comando, se producirá un error. Para comenzar a solucionarlo, podemos analizar la información sobre la excepción en los datos de la traza de pila:

Error al crear el bean con nombre 'sentimentController': Falló la inyección de dependencias autowired; la excepción anidada es java.lang.IllegalArgumentException: No se pudo resolver el marcador de posición 'sa.logic.api.url' en el valor "${sa.logic.api.url}"

Lo más importante para nosotros aquí es mencionar la imposibilidad de determinar el valor sa.logic.api.url. Analicemos el código en el que se produce el error.

▍Análisis del código de la aplicación Java

Aquí está el fragmento de código en el que ocurre el 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 hay un campo saLogicApiUrl. Su valor se establece mediante la propiedad sa.logic.api.url.
Cadena saLogicApiUrl se concatena con el valor /analyse/sentiment. Juntos forman la dirección para realizar la llamada al microservicio que analiza el texto.

▍Asignación del valor de la propiedad

En Spring, la fuente estándar de valores de propiedades es el archivo application.properties, que se puede encontrar en sa-webapp/src/main/resources. Pero su uso no es la única manera de establecer valores para las propiedades. También se puede hacer mediante un comando del siguiente tipo:

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

El valor de esta propiedad debe apuntar a la dirección de nuestra aplicación en Python.

Al configurarlo, estamos informando a la aplicación web de Spring sobre a dónde debe dirigirse para realizar las solicitudes de análisis de texto.

Para no complicarnos la vida, decidiremos que la aplicación en Python estará disponible en la dirección localhost:5000 y haremos un esfuerzo por no olvidarlo. Como resultado, el comando para iniciar la aplicación Spring se verá así:

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

En nuestro sistema falta la aplicación en Python

Ahora solo nos queda iniciar la aplicación en Python y el sistema funcionará como se espera.

▍Configuración de la aplicación en Python

Para ejecutar la aplicación en Python, deben estar instalados Python 3 y Pip, y deben estar correctamente configuradas las variables de entorno correspondientes.

▍Instalación de dependencias

Ve a la carpeta del proyecto sa-logic/sa y ejecuta los siguientes comandos:

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

▍Ejecutar la aplicación

Después de instalar las dependencias, estamos listos para ejecutar la aplicación:

python sentiment_analysis.py

Después de ejecutar este comando, se nos informará lo siguiente:

* Ejecutando en http://0.0.0.0:5000/ (Presione CTRL+C para salir)

Esto significa que la aplicación está en funcionamiento y esperando solicitudes en la dirección localhost:5000/

▍Investigación del código

Veamos el código de la aplicación en Python para entender cómo responde a las 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 del objeto Flask.
Definiendo la dirección para realizar solicitudes POST a él.
Extracción de la propiedad sentence del cuerpo de la solicitud.
Inicialización de un objeto anónimo TextBlob y obteniendo el valor polarity para la primera oración recibida en el cuerpo de la solicitud (en nuestro caso, es la única oración que se pasa para análisis).
Retorno de una respuesta, cuyo cuerpo contiene el texto de la oración y el valor calculado para ella polarity.
Ejecutando la aplicación Flask, que estará disponible en la dirección 0.0.0.0:5000 (se puede acceder también usando la estructura como localhost:5000).

Ahora los microservicios que componen la aplicación están en funcionamiento. Están configurados para interactuar entre sí. Así es como se ve el esquema de la aplicación en esta etapa de funcionamiento.

Todos los microservicios que componen la aplicación están en estado operativo

Ahora, antes de continuar, abra la aplicación React en el navegador e intente analizar alguna oración con ella. Si todo se ha hecho correctamente, después de hacer clic en el botón Send verá los resultados del análisis debajo del campo de texto.

En la siguiente sección, hablaremos sobre cómo ejecutar nuestros microservicios en contenedores Docker. Esto es necesario para preparar la aplicación para su ejecución en un clúster de Kubernetes.

Contenedores Docker

Kubernetes es un sistema para automatizar el despliegue, escalado y gestión de aplicaciones en contenedores. También se le conoce como "orquestador de contenedores" (container orchestrator). Si Kubernetes trabaja con contenedores, antes de utilizar este sistema necesitamos primero adquirir dichos contenedores. Pero primero hablemos sobre qué son los contenedores. Probablemente, la mejor respuesta a la pregunta de qué son se puede encontrar en la documentación Docker:

Una imagen de contenedor es un paquete ligero, autónomo y ejecutable que contiene una aplicación, incluyendo todo lo necesario para ejecutarla: el código de la aplicación, el entorno de ejecución, las herramientas del sistema y las bibliotecas, así como la configuración. Las aplicaciones en contenedores pueden ejecutarse en entornos Linux y Windows, y funcionarán de la misma manera sin importar la infraestructura.

Esto significa que los contenedores se pueden ejecutar en cualquier computadora, incluidas las servidors de producción, y las aplicaciones incluidas en ellos funcionarán de manera consistente en cualquier entorno.

Para explorar las características de los contenedores y compararlas con otros métodos de ejecución de aplicaciones, consideremos el ejemplo de servir una aplicación React utilizando una máquina virtual y un contenedor.

▍Servicio de archivos estáticos de una aplicación React utilizando una máquina virtual

Al intentar organizar el servicio de archivos estáticos mediante máquinas virtuales, nos encontraremos con las siguientes desventajas:

Uso ineficiente de recursos, ya que cada máquina virtual representa un sistema operativo completo.
Dependencia de la plataforma. Lo que funciona en una computadora local puede no funcionar en el servidor de producción.
Escalado lento y que consume muchos recursos de una solución basada en máquinas virtuales.

Servidor web Nginx sirviendo archivos estáticos, que se ejecuta en una máquina virtual

Si, en cambio, utilizamos contenedores para resolver una tarea similar, en comparación con las máquinas virtuales, podremos señalar las siguientes ventajas:

Uso eficiente de recursos: trabajo con el sistema operativo a través de Docker.
Independencia de la plataforma. Un contenedor que el desarrollador pueda ejecutar en su computadora funcionará en cualquier lugar.
Despliegue ligero gracias al uso de capas de imágenes.

Servidor web Nginx sirviendo archivos estáticos, ejecutado en un contenedor.

Hemos comparado máquinas virtuales y contenedores solo en algunos puntos, pero incluso esto es suficiente para percibir las fortalezas de los contenedores. Aquí puede encontrar detalles sobre los contenedores Docker.

▍Construcción de la imagen del contenedor para la aplicación React.

El bloque de construcción principal de un contenedor Docker es el archivo Dockerfile. Al inicio de este archivo, se registra la imagen base del contenedor, luego se incluye una secuencia de instrucciones que indican el orden de creación del contenedor que se adaptará a las necesidades de una determinada aplicación.

Antes de empezar a trabajar con el archivo Dockerfile, recordemos lo que hicimos para preparar los archivos de la aplicación React para desplegar en el servidor Nginx:

Construcción del paquete de la aplicación React (npm run build).
Ejecutar el servidor Nginx.
Copiar el contenido del directorio build desde la carpeta del proyecto sa-frontend en la carpeta del servidor nginx/html.

A continuación, verá paralelismos entre la creación del contenedor y las acciones mencionadas anteriormente que se realizan en la computadora local.

▍Preparación del archivo Dockerfile para la aplicación SA-Frontend.

Las instrucciones que contendrá Dockerfile para la aplicación SA-Frontend, consisten en solo dos comandos. Esto se debe a que un grupo de desarrolladores de Nginx preparó una base imagen para Nginx, que utilizaremos para crear nuestra imagen. Estos son los dos pasos que necesitamos describir:

La base de la imagen debe ser la imagen de Nginx.
El contenido de la carpeta sa-frontend/build debe copiarse en la carpeta de la imagen nginx/html.

Si se pasa de esta descripción al archivo Dockerfile, se verá así:

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

Como puede ver, aquí es todo muy simple, y el contenido del archivo es bastante legible y comprensible. Este archivo le dice al sistema que debe tomar la imagen nginx con todo lo que ya tiene, y copiar el contenido del directorio build en el directorio nginx/html.

Aquí puede surgir la pregunta de cómo sé a dónde exactamente necesito copiar los archivos de la carpeta build, es decir, de dónde proviene la ruta /usr/share/nginx/html. En realidad, no hay nada complicado aquí. El hecho es que la información correspondiente se puede encontrar en la descripción de la imagen.

▍Creación de la imagen y carga en el repositorio

Antes de que podamos trabajar con la imagen creada, necesitamos enviarla al repositorio de imágenes. Para ello, utilizaremos la plataforma en la nube gratuita para el alojamiento de imágenes Docker Hub. En esta etapa, debes realizar lo siguiente:

Instalar Docker.
Registrarte en el sitio web de Docker Hub.
Iniciar sesión en tu cuenta ejecutando en la terminal el comando del siguiente tipo:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Ahora necesitas, mediante la terminal, cambiar a el directorio sa-frontend y ejecutar allí el comando del siguiente tipo:

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

Aquí y en adelante en comandos similares $DOCKER_USER_ID debes reemplazarlo por tu nombre de usuario en Docker Hub. Por ejemplo, esta parte del comando puede verse así: rinormaloku/sentiment-analysis-frontend.

A su vez, este comando puede acortarse eliminando de él -f Dockerfile, ya que en la carpeta donde estamos ejecutando este comando, ya existe ese archivo.

Para enviar la imagen creada al repositorio, necesitaremos el siguiente comando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Después de ejecutarlo, verifica la lista de tus repositorios en Docker Hub para asegurarte de que la carga de la imagen en el almacenamiento en la nube fue exitosa.

▍Ejecutando el contenedor

Ahora cualquiera puede descargar y ejecutar la imagen conocida como $DOCKER_USER_ID/sentiment-analysis-frontend. Para hacerlo, debes seguir la siguiente secuencia de comandos:

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

Ahora el contenedor está en funcionamiento y podemos continuar trabajando, creando otras imágenes que necesitemos. Pero antes de seguir, aclaremos la construcción 80:80, que se encuentra en el comando para iniciar la imagen y puede parecer confusa.

El primer número 80 es el número de puerto del host (es decir, del ordenador local).
El segundo número 80 es el puerto del contenedor al que debe redirigirse la solicitud.

Consideremos la siguiente ilustración.

Redirección de puertos

El sistema redirige las solicitudes desde el puerto <hostPort> al puerto <containerPort>. Es decir, una solicitud al puerto 80 del ordenador se redirige al puerto 80 del contenedor.

Dado que el puerto 80 está abierto en el ordenador local, puedes acceder a la aplicación desde este ordenador en la dirección localhost:80Si su sistema no es compatible con Docker, la aplicación se puede ejecutar en una máquina virtual Docker, cuya dirección tendrá el siguiente formato :80. Para averiguar la dirección IP de la máquina virtual Docker, se puede utilizar el comando docker-machine ip.

En esta etapa, después de que el contenedor de la aplicación frontend se haya iniciado correctamente, debería poder abrir su página en el navegador.

▍Archivo .dockerignore

Al construir la imagen de la aplicación SA-Frontend, hemos notado que este proceso puede ser extremadamente lento. Esto ocurre porque se debe enviar al demonio de Docker el contexto de construcción de la imagen. El directorio que representa el contexto de construcción se especifica en el último argumento del comando docker build. En nuestro caso, al final de este comando hay un punto. Esto hace que la siguiente estructura se incluya en el contexto de construcción:

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

Pero solo necesitamos la carpeta build. Cargar cualquier otra cosa es una pérdida de tiempo. La construcción se puede acelerar indicando a Docker qué directorios pueden ser ignorados. Precisamente para esto necesitamos el archivo .dockerignore. Si está familiarizado con el archivo .gitignore, la estructura de este archivo seguramente le resultará familiar. Enumera los directorios que el sistema de construcción de la imagen puede ignorar. En nuestro caso, el contenido de este archivo es el siguiente:

node_modules
src
public

Archivo .dockerignore debe estar en la misma carpeta que el archivo Dockerfile. Ahora, la construcción de la imagen tomará solo unos segundos.

Ahora pasemos a la imagen para la aplicación Java.

▍Construcción de la imagen del contenedor para la aplicación Java

¿Sabe qué? Ya ha estudiado todo lo necesario para crear imágenes de contenedores. Por eso esta sección será bastante corta.

Abra el archivo Dockerfile, que se encuentra en la carpeta del proyecto sa-webapp. Si lee el texto de este archivo, encontrará solo dos nuevas construcciones que comienzan con las palabras clave ENV y EXPOSE:

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

La palabra clave ENV permite declarar variables de entorno dentro de los contenedores Docker. En particular, en nuestro caso, permite establecer la URL para acceder a la API de la aplicación que realiza el análisis de texto.

La palabra clave EXPOSE permite indicar a Docker que debe abrir el puerto. Vamos a utilizar este puerto durante el trabajo con la aplicación. Aquí se puede notar que en Dockerfile para la aplicación SA-Frontend no hay tal comando. Esto es solo para fines de documentación, en otras palabras, esta construcción está destinada a quien leerá Dockerfile.

La construcción de la imagen y su envío al repositorio se ve exactamente igual que en el ejemplo anterior. Si aún no estás muy seguro de tus habilidades, los comandos correspondientes se pueden encontrar en el archivo README.md en la carpeta sa-webapp.

▍Construcción de la imagen del contenedor para la aplicación Python

Si miras el contenido del archivo Dockerfile en la carpeta sa-logic, no encontrarás nada nuevo allí. Los comandos para construir la imagen y enviarla al repositorio también deberían ser familiares, pero, al igual que con otras nuestras aplicaciones, se pueden encontrar en el archivo README.md en la carpeta sa-logic.

▍Pruebas de aplicaciones en contenedores

¿Puedes confiar en algo que no has probado? Yo tampoco puedo. Probemos nuestros contenedores.

Iniciaremos el contenedor de la aplicación sa-logic y lo configuraremos para escuchar en el puerto 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Iniciaremos el contenedor de la aplicación sa-webapp y lo configuraremos para escuchar en el puerto 8080. Además, necesitamos configurar el puerto en el que la aplicación Python estará a la espera de solicitudes de la aplicación Java, reasignando la variable de entorno SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Para saber cómo determinar la dirección IP del contenedor o de la máquina virtual de Docker, consulta el archivo README.

Iniciaremos el contenedor de la aplicación sa-frontend:

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

Ahora todo está listo para ir al navegador en la dirección localhost:80 y probar la aplicación.

Ten en cuenta que si cambiaste el puerto para sa-webapp, o si estás trabajando con una máquina virtual de Docker, necesitarás editar el archivo App.js de la carpeta sa-frontend, cambiando la dirección IP o el número de puerto en el método analyzeSentence(), substituyendo los datos obsoletos con información actual. Después de eso, necesitas reconstruir la imagen y usarla.

Así es como se ve el esquema de nuestra aplicación ahora.

Los microservicios se ejecutan en contenedores

Resultados: ¿por qué necesitamos un clúster de Kubernetes?

Acabamos de estudiar los archivos Dockerfile, hablamos sobre cómo construir imágenes y enviarlas al repositorio de Docker. Además, aprendimos a acelerar la construcción de imágenes utilizando el archivo .dockerignoreEn resumen, nuestros microservicios ahora se ejecutan en contenedores Docker. Aquí puede surgir una pregunta completamente válida sobre por qué necesitamos Kubernetes. La respuesta a esta pregunta se abordará en la segunda parte de este material. Mientras tanto, reflexione sobre la siguiente cuestión:
Supongamos que nuestra aplicación web para el análisis de textos se ha vuelto mundialmente popular. Cada minuto recibe millones de solicitudes. Esto significa que los microservicios sa-webapp y sa-logic estarán bajo una gran carga. ¿Cómo escalar los contenedores en los que se ejecutan los microservicios?

Fuente: habr.com