🥇Tutorial de Kubernetes Parte 1: Aplicaciones, Microservicios y Contenedores

A petición nuestra, Habr creó un centro Kubernetes y nos complace colocar la primera publicación en el mismo. ¡Suscribir!

Kubernetes es fácil. ¿Por qué los bancos me pagan mucho dinero por trabajar en esta área, mientras que cualquiera puede dominar esta tecnología en unas pocas horas?

Si duda de que Kubernetes se pueda aprender tan rápido, le sugiero que intente hacerlo usted mismo. Es decir, habiendo dominado este material, podrá ejecutar una aplicación basada en microservicios en un clúster de Kubernetes. Puedo garantizar esto, porque es en la misma metodología que uso aquí que les enseño a nuestros clientes cómo trabajar con Kubernetes. ¿Qué hace que esta guía sea diferente de otras? En realidad, muchas cosas. Por lo tanto, la mayoría de estos materiales comienzan con una explicación de cosas simples: los conceptos de Kubernetes y las funciones del comando kubectl. Los autores de estos artículos asumen que su lector está familiarizado con el desarrollo de aplicaciones, los microservicios y los contenedores Docker. Iremos por el otro lado. Primero, hablemos sobre cómo ejecutar una aplicación basada en microservicios en una computadora. Luego veremos cómo crear imágenes de contenedores para cada microservicio. Y después nos familiarizaremos con Kubernetes y analizaremos el despliegue de una aplicación basada en microservicios en un clúster gestionado por Kubernetes.

Este enfoque, con un acercamiento gradual a Kubernetes, brindará la profundidad de comprensión de lo que está sucediendo que la persona promedio necesita para comprender cuán simple está todo organizado en Kubernetes. Kubernetes es ciertamente una tecnología sencilla, siempre que quien quiera dominarla sepa dónde y cómo se utiliza.

Ahora, sin más preámbulos, pongámonos manos a la obra y hablemos de la aplicación con la que trabajaremos.

aplicación experimental

Nuestra aplicación realizará una sola función. Toma, como entrada, una oración, después de lo cual, utilizando herramientas de análisis de texto, realiza un análisis de sentimiento de esta oración, obteniendo una evaluación de la actitud emocional del autor de la oración hacia un objeto determinado.

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

Aplicación web de análisis de sentimiento

Desde un punto de vista técnico, la aplicación consta de tres microservicios, cada uno de los cuales resuelve un determinado conjunto de tareas:

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

Es importante tener en cuenta que los microservicios no existen de forma aislada. Implementan la idea de "separación de funciones", pero al mismo tiempo necesitan interactuar entre sí.

Flujos de datos en la aplicación

En el diagrama anterior, puede ver las etapas numeradas del sistema, que ilustran los flujos de datos en la aplicación. Vamos a desglosarlos:

El navegador solicita un archivo del servidor. index.html (que a su vez carga el paquete de la aplicación React).
El usuario interactúa con la aplicación, esto provoca una llamada a una aplicación web basada en Spring.
La aplicación web reenvía la solicitud para analizar el texto a la aplicación Python.
La aplicación de Python analiza el sentimiento del texto y devuelve el resultado como respuesta a la solicitud.
La aplicación Spring envía una respuesta a la aplicación React (que, a su vez, muestra el resultado del texto analizado al usuario).

El código para todas estas aplicaciones se puede encontrar aquí. Le recomiendo que copie este repositorio ahora mismo, ya que tenemos muchos experimentos interesantes con él por delante.

Ejecutar una aplicación basada en microservicios en la máquina local

Para que la aplicación funcione, debemos iniciar los tres microservicios. Comencemos con la más bonita de ellas: la aplicación frontal.

▍Configuración de React para el desarrollo local

Para ejecutar una aplicación React, debe instalar el marco Node.js y NPM en su computadora. Después de instalar todo esto, vaya usando la terminal a la carpeta del proyecto sa-frontend y ejecuta el siguiente comando:

npm install

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

npm start

Eso es todo. La aplicación React ahora se está ejecutando y se puede acceder navegando a la dirección del navegador localhost:3000. Puedes cambiar algo en su código. Inmediatamente verá el efecto de estos cambios en el navegador. Esto es posible gracias al llamado reemplazo "en caliente" de módulos. Gracias a esto, el desarrollo front-end se convierte en una experiencia sencilla y agradable.

▍Preparación de una aplicación React para producción

Con el fin de usar una aplicación React, necesitamos convertirla en un conjunto de archivos estáticos y servirlos a los clientes que usan un servidor web.

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

npm run build

Esto creará un directorio en la carpeta del proyecto. build. Contendrá todos los archivos estáticos necesarios para que funcione la aplicación React.

▍Servir archivos estáticos con Nginx

Primero debe instalar y ejecutar el servidor web Nginx. es puede descargarlo y encontrar instrucciones para instalarlo y ejecutarlo. 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 durante el ensamblaje de la aplicación React index.html estará disponible en [your_nginx_installation_dir]/html/index.html. Este es el archivo que, por defecto, emite el servidor Nginx al acceder a él. El servidor está configurado para escuchar en un puerto. 80, pero puedes personalizarlo como quieras editando el archivo [your_nginx_installation_dir]/conf/nginx.conf.

Ahora abre tu navegador y ve a localhost:80. Verá la página de la aplicación React.

Aplicación React servida por el servidor Nginx

Si ahora ingresa algo en el campo Type your sentence y presiona el boton Send - nada pasará. Pero, si observa la consola, puede ver mensajes de error allí. Para comprender exactamente dónde ocurren estos errores, analicemos el código de la aplicación.

▍Análisis del código de la aplicación front-end

Mirando el código del archivo App.js, podemos ver que haciendo clic en el botón Send llama a un método analyzeSentence(). El código para este método se muestra a continuación. Al mismo tiempo, preste atención al hecho de que para cada línea en la que hay un comentario del formulario # Номер, hay una explicación debajo del código. De la misma manera, analizaremos otros 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. La URL a la que se realiza la solicitud POST. Se supone que esta dirección es una aplicación que espera tales solicitudes.

2.El cuerpo de la solicitud enviado a la aplicación. Aquí hay un cuerpo de solicitud de ejemplo:

{
    sentence: "I like yogobella!"
}

3.Cuando se recibe una respuesta a una solicitud, se actualiza el estado del componente. Esto hace que el componente se vuelva a renderizar. Si recibimos datos (es decir, un objeto JSON que contiene los datos ingresados y la puntuación de texto calculada), generaremos el componente Polaritysiempre y cuando se cumplan las condiciones. Así es como describimos el componente:

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

El código parece funcionar bastante bien. ¿Qué está mal aquí, de todos modos? Si supone que en la dirección a la que la aplicación intenta enviar una solicitud POST, todavía no hay nada que pueda aceptar y procesar esta solicitud, entonces tendrá toda la razón. Es decir, para procesar 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 Spring que pueda aceptar una solicitud POST

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

Para implementar una aplicación Spring, necesita JDK8 y Maven y variables de entorno configuradas correctamente. Después de instalar todo esto, puede continuar trabajando en nuestro proyecto.

▍Empacar la aplicación en un archivo jar

Navega, usando la terminal, a la carpeta sa-webapp e ingrese el siguiente comando:

mvn install

Después de ejecutar este comando en la carpeta sa-webapp se creará el directorio target. Aquí es donde se ubicará la aplicación Java, empaquetada en un archivo jar, representado por el archivo sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Lanzamiento de una aplicación Java

Ir a la carpeta target y ejecuta la aplicación con el siguiente comando:

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

Se producirá un error al ejecutar este comando. Para comenzar a solucionarlo, podemos analizar los detalles de la excepción en los datos de seguimiento 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}"

Para nosotros, lo más importante aquí es la mención de la imposibilidad de aclarar el significado. sa.logic.api.url. Analicemos el código donde ocurre el error.

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

Aquí está el fragmento de código donde se produce 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 lo establece la propiedad sa.logic.api.url.
Cadena saLogicApiUrl se concatena con valor /analyse/sentiment. Juntos forman una dirección para realizar una llamada al microservicio que realiza el análisis de texto.

▍Establecer un valor de propiedad

En Spring, la fuente predeterminada de valores de propiedad es un archivo application.properties, que se puede encontrar en sa-webapp/src/main/resources. Pero usarlo no es la única forma de establecer valores de propiedad. También puedes hacer esto con el siguiente comando:

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 Python.

Al configurarlo, le decimos a la aplicación web Spring dónde debe ir para realizar solicitudes de análisis de texto.

Para no complicarnos la vida, decidiremos que la aplicación Python estará disponible en localhost:5000 y trata de 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

A nuestro sistema le falta una aplicación de Python

Ahora solo tenemos que ejecutar la aplicación Python y el sistema funcionará como se esperaba.

▍Configuración de una aplicación de Python

Para ejecutar una aplicación de Python, debe tener Python 3 y Pip instalados, y debe tener las variables de entorno adecuadas configuradas correctamente.

▍Instalar dependencias

Ir 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

▍Lanzamiento de la aplicación

Con las dependencias instaladas, estamos listos para ejecutar la aplicación:

python sentiment_analysis.py

Luego de ejecutar este comando, se nos indicará lo siguiente:

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

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

▍Investigación de código

Veamos el código de la aplicación 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 de objetos Flask.
Especificar la dirección para realizar solicitudes POST.
Recuperando una propiedad sentence del cuerpo de la solicitud.
Inicialización de objetos anónimos TextBlob y obteniendo el valor polarity para la primera propuesta recibida en el cuerpo de la solicitud (en nuestro caso, esta es la única propuesta enviada para análisis).
Devolver una respuesta, cuyo cuerpo contiene el texto de la oferta y el indicador calculado para ella polarity.
Lanzamiento de la aplicación Flask, que estará disponible en 0.0.0.0:5000 (también puede acceder a él mediante una construcción de la forma localhost:5000).

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

Todos los microservicios que componen la aplicación se llevan a un estado saludable

Ahora, antes de continuar, abra la aplicación React en un navegador e intente analizar alguna oración con ella. Si todo se hace correctamente, después de presionar el botón Send verá los resultados del análisis debajo del cuadro 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 que se ejecute en el clúster de Kubernetes.

Contenedores Docker

Kubernetes es un sistema para automatizar la implementación, el escalado y la gestión de aplicaciones en contenedores. También se le llama "orquestador de contenedores". Si Kubernetes funciona con contenedores, entonces, antes de usar este sistema, primero debemos adquirir estos contenedores. Pero primero, hablemos de qué son los contenedores. Quizás la mejor respuesta a la pregunta de qué es se puede encontrar en documentación a la ventana acoplable:

Una imagen de contenedor es un paquete ejecutable ligero e independiente que contiene una aplicación, que incluye todo lo necesario para ejecutarla: código de la aplicación, entorno de tiempo de ejecución, herramientas y bibliotecas del sistema, configuración. Los programas en contenedores se pueden usar en entornos Linux y Windows y siempre funcionarán igual, independientemente de la infraestructura.

Esto significa que los contenedores se pueden ejecutar en cualquier computadora, incluidos los servidores de producción, y en cualquier entorno, las aplicaciones contenidas en ellos funcionarán de la misma manera.

Para explorar las características de los contenedores y compararlas con otras formas de ejecutar aplicaciones, veamos el ejemplo de servir una aplicación React usando una máquina virtual y un contenedor.

▍Servir archivos estáticos de una aplicación React usando una máquina virtual

Al tratar de organizar el mantenimiento de archivos estáticos utilizando máquinas virtuales, nos encontraremos con las siguientes desventajas:

Uso ineficiente de los recursos, ya que cada máquina virtual es un sistema operativo completo.
Dependencia de la plataforma. Lo que funciona en una computadora local puede no funcionar en un servidor de producción.
Escalado lento y con uso intensivo de recursos de una solución de máquina virtual.

Servidor web Nginx que sirve archivos estáticos que se ejecutan en una máquina virtual

Si los contenedores se utilizan para resolver un problema similar, entonces, en comparación con las máquinas virtuales, se pueden observar las siguientes fortalezas:

Uso eficiente de los recursos: trabajar con el sistema operativo mediante Docker.
Independencia de la plataforma. Un contenedor que un desarrollador puede ejecutar en su propia computadora se ejecutará en cualquier lugar.
Implementación ligera mediante el uso de capas de imagen.

Servidor web Nginx que sirve archivos estáticos que se ejecutan en un contenedor

Solo hemos comparado máquinas virtuales y contenedores en algunos puntos, pero incluso eso es suficiente para tener una idea de las fortalezas de los contenedores. es Puede encontrar detalles sobre los contenedores de Docker.

▍Creación de una imagen de contenedor para una aplicación React

El componente básico de un contenedor Docker es el archivo Dockerfile. Al inicio de este archivo se registra una imagen base del contenedor, luego se incluye una secuencia de instrucciones que indican cómo crear un contenedor que satisfaga las necesidades de una aplicación.

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

Creación de un paquete de aplicación React (npm run build).
Iniciando el servidor Nginx.
Copiar el contenido de un directorio build de la carpeta del proyecto sa-frontend a la carpeta del servidor nginx/html.

A continuación, puede ver los paralelos entre la creación de un contenedor y las acciones anteriores realizadas en la computadora local.

▍Preparación de un Dockerfile para la aplicación SA-Frontend

Instrucciones a incluir en Dockerfile Para aplicación SA-Frontend, consta de sólo dos comandos. El caso es que el equipo de desarrollo de Nginx ha preparado una base imagen para Nginx, que usaremos para construir nuestra imagen. Estos son los dos pasos que debemos describir:

Debe hacer que la imagen de Nginx sea la base de la imagen.
contenido de la carpeta sa-frontend/build necesita copiar a la carpeta de imágenes nginx/html.

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

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

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

Aquí puede tener una pregunta sobre cómo sé exactamente dónde copiar los archivos de la carpeta build, es decir, de dónde vino el camino /usr/share/nginx/html. De hecho, aquí tampoco hay nada complicado. El hecho es que la información relevante se puede encontrar en descripción imagen.

▍Montar la imagen y subirla al repositorio

Antes de que podamos trabajar con una imagen completa, debemos enviarla al repositorio de imágenes. Para ello, utilizaremos la plataforma gratuita de alojamiento de imágenes basada en la nube Docker Hub. En esta etapa del trabajo, debe hacer lo siguiente:

Instalar Docker.
Regístrese en el sitio de Docker Hub.
Inicie sesión en su cuenta ejecutando el siguiente comando en la terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Ahora necesitas, usando la terminal, ir al directorio sa-frontend y ejecute el siguiente comando allí:

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

Aquí y abajo en comandos similares $DOCKER_USER_ID debe reemplazarse con su nombre de usuario en Docker Hub. Por ejemplo, esta parte del comando podría verse así: rinormaloku/sentiment-analysis-frontend.

En este caso, este comando se puede acortar eliminándolo -f Dockerfile, ya que la carpeta en la que ejecutamos este comando ya tiene este archivo.

Para enviar la imagen terminada al repositorio, necesitamos el siguiente comando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Después de completarlo, verifique su lista de repositorios en Docker Hub para ver si la imagen se envió con éxito al almacenamiento en la nube.

▍Inicio de un contenedor

Ahora cualquiera puede descargar y ejecutar la imagen conocida como $DOCKER_USER_ID/sentiment-analysis-frontend. Para hacer esto, debe ejecutar 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 se está ejecutando y podemos continuar trabajando creando otras imágenes que necesitemos. Pero antes de continuar, entendamos el diseño. 80:80, que se encuentra en el comando para ejecutar la imagen y puede parecer confuso.

Primer número 80 es el número de puerto del host (es decir, la computadora local).
Segundo numero 80 es el puerto del contenedor al que se debe redirigir la solicitud.

Considere la siguiente ilustración.

Reenvío de puertos

El sistema reenvía las solicitudes desde el puerto. <hostPort> al puerto <containerPort>. Es decir, acceder al puerto 80 la computadora es redirigida a un puerto 80 envase.

Desde el puerto 80 abierto en la computadora local, puede acceder a la aplicación desde esta computadora en localhost:80. Si su sistema no es compatible con Docker, puede ejecutar la aplicación en una máquina virtual Docker, cuya dirección se verá así <docker-machine ip>:80. Para averiguar la dirección IP de la máquina virtual Docker, puede usar el comando docker-machine ip.

En este punto, una vez que el contenedor de la aplicación front-end se haya iniciado correctamente, debería poder abrir su página en un navegador.

▍.dockerignore archivo

Creación de la imagen de la aplicación SA-Frontend, podríamos notar que este proceso es extremadamente lento. Esto se debe a que el contexto de creación de la imagen debe enviarse al demonio de Docker. El directorio que representa el contexto de compilación se proporciona como último argumento del comando. docker build. En nuestro caso, hay un punto al final de este comando. Esto da como resultado que se incluya la siguiente estructura en el contexto del ensamblaje:

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

Pero de todas las carpetas presentes aquí, solo necesitamos una carpeta build. Descargar cualquier otra cosa es una pérdida de tiempo. Puede acelerar la compilación diciéndole a Docker qué directorios ignorar. Para hacer esto, necesitamos un archivo .dockerignore. Usted, si está familiarizado con el archivo .gitignore, la estructura de este archivo probablemente le resultará familiar. Enumera los directorios que el sistema de creación de imágenes puede ignorar. En nuestro caso, el contenido de este archivo se ve así:

node_modules
src
public

Expediente .dockerignore debe estar en la misma carpeta que el archivo Dockerfile. Ahora el montaje de la imagen tardará unos segundos.

Tratemos ahora con la imagen para una aplicación Java.

▍Creación de una imagen de contenedor para una aplicación Java

Sabes qué, y ya aprendiste todo lo que necesitas para crear imágenes de contenedores. Es por eso que esta sección será muy corta.

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

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

Ключевое слово ENV le permite declarar variables de entorno dentro de contenedores Docker. En concreto, en nuestro caso, permite establecer una URL para acceder a la API de la aplicación que realiza el análisis de texto.

Ключевое слово EXPOSE le permite decirle a Docker que abra un puerto. Vamos a utilizar este puerto mientras trabajamos con la aplicación. Aquí se puede ver que en Dockerfile Para aplicación SA-Frontend no hay tal comando. Esto es solo para fines de documentación, en otras palabras, esta construcción es para el lector Dockerfile.

Crear la imagen y enviarla al repositorio se ve exactamente como en el ejemplo anterior. Si aún no tiene mucha confianza en sus habilidades, los comandos correspondientes se pueden encontrar en el archivo README.md en carpeta sa-webapp.

▍Creación de una imagen de contenedor para una aplicación de Python

Si echas un vistazo al contenido del archivo Dockerfile en carpeta sa-logicno encontrarás nada nuevo allí. Los comandos para construir la imagen y enviarla al repositorio también deberían resultarle familiares, pero, como es el caso con nuestras otras aplicaciones, se pueden encontrar en el archivo README.md en carpeta sa-logic.

▍Prueba de aplicaciones en contenedores

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

Comencemos el contenedor de la aplicación. sa-logic y configurarlo para escuchar en un puerto 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Comencemos el contenedor de la aplicación. sa-webapp y configurarlo para escuchar en un puerto 8080. Además, debemos establecer el puerto en el que la aplicación Python escuchará las 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://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

Para obtener información sobre cómo averiguar la dirección IP de un contenedor o una máquina virtual de Docker, consulte el archivo README.

Comencemos 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 navegar en el navegador a la dirección. localhost:80 y prueba la aplicación.

Tenga en cuenta que si cambia el puerto de sa-webapp, o si está ejecutando una VM de Docker, deberá editar el archivo App.js de la carpeta sa-frontendcambiando la dirección IP o el número de puerto en el método analyzeSentence()mediante la sustitución de información actual en lugar de datos obsoletos. Después de eso, debe volver a ensamblar la imagen y usarla.

Así es como se ve nuestro diagrama de aplicación ahora.

Los microservicios se ejecutan en contenedores

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

Acabamos de revisar los archivos. Dockerfile, habló sobre cómo crear imágenes y enviarlas a un repositorio de Docker. Además, aprendimos a agilizar el montaje de imágenes utilizando el archivo .dockerignore. Como resultado, nuestros microservicios ahora se ejecutan en contenedores Docker. Aquí puede tener una pregunta completamente justificada sobre por qué necesitamos Kubernetes. La respuesta a esta pregunta se dedicará a la segunda parte de este material. Mientras tanto, considere la siguiente pregunta:
Supongamos que nuestra aplicación web de análisis de texto se ha vuelto popular en todo el mundo. Cada minuto le llegan millones de solicitudes. Esto significa que los microservicios sa-webapp и sa-logic estará bajo un estrés enorme. ¿Cómo escalar contenedores que ejecutan microservicios?

Fuente: habr.com

Tutorial de Kubernetes, parte 1: aplicaciones, microservicios y contenedores