🥇 Guia de Kubernetes, parte 1: aplicativos, microserviços e contêineres

A pedido nosso, o Habr criou um hub Kubernetes e estamos felizes em publicar a primeira postagem nele. Inscreva-se!

Kubernetes é simples. Por que os bancos me pagam tanto para trabalhar nessa área, enquanto qualquer pessoa pode dominar essa tecnologia em apenas algumas horas?

Se você duvida que Kubernetes pode ser aprendido tão rapidamente, eu sugiro que você tente fazer isso por conta própria. Dominando este material, você será capaz de implantar um aplicativo baseado em microsserviços em um cluster Kubernetes. Posso garantir isso, pois é exatamente com essa metodologia, utilizada aqui, que ensino nossos clientes a trabalhar com Kubernetes. O que distingue este guia dos outros? Na verdade, muitas coisas. A maioria desses materiais começa explicando conceitos básicos — conceitos de Kubernetes e detalhes do comando kubectl. Os autores desses materiais supõem que seus leitores já estão familiarizados com desenvolvimento de aplicativos, microsserviços e contêineres Docker. Nós vamos seguir um caminho diferente. Primeiro, falaremos sobre como rodar um aplicativo baseado em microsserviços em seu computador. Depois, iremos construir imagens de contêiner para cada microsserviço. Somente após isso, nos familiarizaremos com Kubernetes e discutiremos o lançamento do aplicativo baseado em microsserviços em um cluster gerenciado pelo Kubernetes.

Essa abordagem, com uma aproximação gradual ao Kubernetes, proporcionará a profundidade de entendimento necessária para que uma pessoa comum compreenda como tudo é simples no Kubernetes. Kubernetes é, sem dúvida, uma tecnologia simples, desde que, quem deseja dominá-la, saiba onde e como ela é utilizada.

Agora, sem mais delongas, vamos ao trabalho e falemos sobre o aplicativo com o qual estaremos trabalhando.

Aplicativo experimental

Nosso aplicativo terá apenas uma função. Ele aceita, como entrada, uma frase, e então, utilizando ferramentas de análise de texto, realiza a análise de sentimento dessa frase, obtendo uma avaliação da relação emocional do autor da frase com certo objeto.

Aqui está como a janela principal deste aplicativo se parece.

Web aplicativo para análise de sentimentos de textos

Do ponto de vista técnico, o aplicativo consiste em três microserviços, cada um dos quais resolve um conjunto específico de tarefas:

SA-Frontend — servidor web Nginx que serve arquivos estáticos do React.
SA-WebApp — aplicativo web escrito em Java que processa solicitações do frontend.
SA-Logic — aplicativo em Python que realiza a análise de sentimento do texto.

É importante notar que os microserviços não existem isoladamente. Eles implementam a ideia de "separação de responsabilidades", mas precisam interagir uns com os outros.

Fluxos de dados no aplicativo

No diagrama acima, é possível ver as etapas numeradas do funcionamento do sistema, ilustrando os fluxos de dados no aplicativo. Vamos analisá-las:

O navegador solicita ao servidor um arquivo index.html que, por sua vez, faz o download do pacote do aplicativo React.
O usuário interage com o aplicativo, o que gera uma chamada ao aplicativo web baseado em Spring.
O aplicativo web redireciona a solicitação para realizar a análise de texto para o aplicativo Python.
O aplicativo Python realiza a análise de sentimento do texto e retorna o resultado como resposta à solicitação.
O aplicativo Spring envia a resposta ao aplicativo React (que, por sua vez, mostra o resultado da análise de texto ao usuário).

O código para todos esses aplicativos pode ser encontrado aqui. Recomendo que você copie este repositório agora mesmo, pois temos muitos experimentos interessantes pela frente.

Executando o aplicativo baseado em microserviços no computador local

Para que o aplicativo funcione, precisamos iniciar os três microserviços. Começaremos pelo mais bonito deles — o aplicativo frontend.

▍Configurando o React para desenvolvimento local

Para executar o aplicativo React, você precisa instalar a plataforma Node.js e o NPM em seu computador. Após instalar tudo isso, use o terminal para acessar a pasta do projeto sa-frontend e execute o seguinte comando:

npm install

Ao executar este comando, as dependências do aplicativo React serão baixadas na pasta node_modules cuja lista está disponível no arquivo package.json. Após a conclusão do download das dependências, execute o seguinte comando na mesma pasta:

npm start

É isso aí. Agora o aplicativo React está em execução e pode ser acessado no navegador pelo endereço localhost:3000. Você pode fazer algumas alterações no código. Os efeitos dessas alterações serão instantaneamente visíveis no navegador. Isso é possível graças ao que se chama de "substituição a quente" de módulos. Com isso, o desenvolvimento frontend se torna uma tarefa simples e agradável.

▍Preparando a aplicação React para produção

Para um uso real da aplicação React, precisamos convertê-la em um conjunto de arquivos estáticos e servi-los aos clientes usando um servidor web.

Para compilar a aplicação React, novamente, usando o terminal, vá para a pasta sa-frontend e execute o seguinte comando:

npm run build

Isso resultará na criação de um diretório na pasta do projeto build. Nele estarão todos os arquivos estáticos necessários para o funcionamento da aplicação React.

▍Servindo arquivos estáticos com Nginx

Primeiro, você precisa instalar e iniciar o servidor web Nginx. Aqui você pode baixá-lo e encontrar instruções para instalação e inicialização. Em seguida, você deve copiar o conteúdo da pasta sa-frontend/build para a pasta [your_nginx_installation_dir]/html.

Com essa abordagem, o arquivo gerado durante o processo de compilação da aplicação React index.html estará disponível no endereço [your_nginx_installation_dir]/html/index.html. Este é o arquivo que, por padrão, o servidor Nginx fornece quando ele é acessado. O servidor está configurado para escutar a porta 80, mas pode ser configurado conforme necessário, editando o arquivo [your_nginx_installation_dir]/conf/nginx.conf.

Agora abra o navegador e vá para o endereço localhost:80. Você verá a página da aplicação React.

Aplicação React servida pelo servidor Nginx

Se você digitar algo no campo Type your sentence e clicar no botão Send — nada acontecerá. Mas, se você olhar no console, poderá ver mensagens de erro. Para entender onde exatamente esses erros ocorrem, vamos analisar o código da aplicação.

▍Análise do código da aplicação frontend

Ao olhar para o código do arquivo App.js, podemos ver que ao pressionar o botão Send chama o método analyzeSentence(). O código deste método está listado abaixo. Observe que cada linha com um comentário do tipo # Номер, tem uma explicação abaixo do código. Da mesma forma, analisaremos outros fragmentos do 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 para a qual a requisição POST será enviada. Assume-se que neste endereço há um aplicativo que está aguardando tais requisições.

2.Corpo da requisição enviado ao aplicativo. Aqui está um exemplo do corpo da requisição:

{
    sentence: "I like yogobella!"
}

3.Ao receber a resposta à requisição, o estado do componente é atualizado. Isso provoca uma nova renderização do componente. Se recebermos dados (ou seja, um objeto JSON contendo os dados inseridos e a avaliação calculada do texto), exibiremos o componente Polaridade, pois as condições apropriadas serão atendidas. Aqui está como descrevemos o componente:

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

O código, aparentemente, parece totalmente funcional. O que há de errado? Se você supõe que não há nada no endereço para o qual o aplicativo está tentando enviar a requisição POST que possa aceitar e processar essa requisição, está absolutamente correto. Especificamente, para processar as requisições que chegam ao endereço http://localhost:8080/sentiment, precisamos iniciar um aplicativo web baseado em Spring.

Precisamos de um aplicativo Spring capaz de aceitar requisições POST.

▍Configuração do aplicativo web baseado em Spring

Para implantar um aplicativo Spring, você precisará do JDK8 e Maven, além de variáveis de ambiente configuradas corretamente. Depois de instalar tudo isso, você pode continuar trabalhando no nosso projeto.

▍Empacotando o aplicativo em um arquivo jar

Acesse a pasta sa-webapp e digite o seguinte comando:

mvn install

Após a conclusão deste comando, uma diretório será criado na pasta sa-webapp . Aqui estará o aplicativo Java empacotado em um arquivo jar, apresentado pelo arquivo alvosentiment-analysis-web-0.0.1-SNAPSHOT.jar ▍Executando o aplicativo Java.

e inicie o aplicativo com o seguinte comando:

Vá para a pasta alvo java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

Durante a execução deste comando, ocorrerá um erro. Para começar a corrigi-lo, podemos analisar as informações da exceção nos dados da pilha de chamadas:

Durante a execução deste comando, ocorrerá um erro. Para começar a corrigi-lo, podemos analisar as informações sobre a exceção nos dados da pilha de rastreamento:

Erro ao criar o bean com o nome 'sentimentController': Falha na injeção das dependências autowired; exceção aninhada é java.lang.IllegalArgumentException: Não foi possível resolver o placeholder 'sa.logic.api.url' no valor "${sa.logic.api.url}"

Para nós, aqui, o mais importante é a menção à impossibilidade de determinar o valor sa.logic.api.url. Vamos analisar o código onde o erro ocorre.

▍Análise do código do aplicativo Java

Aqui está um fragmento do código onde o erro ocorre.

@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();
    }
}

No SentimentController há um campo saLogicApiUrl. Seu valor é definido pela propriedade sa.logic.api.url.
String saLogicApiUrl e é concatenado com o valor /analyse/sentiment. Juntos, eles formam o endereço para a realização da chamada ao microserviço, que realiza a análise de texto.

▍Configuração do valor da propriedade

No Spring, a fonte padrão de valores de propriedades é o arquivo application.properties, que pode ser encontrado no caminho sa-webapp/src/main/resources. Mas seu uso não é a única forma de definir valores de propriedades. É possível fazer isso também usando um comando da seguinte forma:

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

O valor desta propriedade deve apontar para o endereço da nossa aplicação Python.

Ao configurá-lo, informamos ao aplicativo da web Spring para onde ele deve se dirigir para realizar as solicitações de análise de texto.

Para não complicarmos a nossa vida, vamos assumir que a aplicação Python estará disponível no endereço localhost:5000 e tentaremos não esquecer disso. Como resultado, o comando para iniciar a aplicação Spring será assim:

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

O nosso sistema está faltando a aplicação Python

Agora, só precisamos iniciar a aplicação Python e o sistema funcionará conforme esperado.

▍Configuração da aplicação Python

Para executar a aplicação Python, você deve ter o Python 3 e Pip instalados e as variáveis de ambiente correspondentes devem estar corretamente configuradas.

▍Instalação de dependências

Acesse a pasta do projeto sa-logic/sa e execute os seguintes comandos:

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

▍Iniciar a aplicação

Após a instalação das dependências, estamos prontos para iniciar o aplicativo:

python sentiment_analysis.py

Após executar este comando, seremos informados do seguinte:

* Executando em http://0.0.0.0:5000/ (Pressione CTRL+C para sair)

Isso significa que o aplicativo está em execução e esperando por solicitações em localhost:5000/

▍Exploração do código

Vamos analisar o código do aplicativo Python para entender como ele reage às solicitações:

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

Inicialização do objeto Flask.
Definindo o endereço para o qual serão feitas as solicitações POST.
Extraindo a propriedade sentence do corpo da solicitação.
Inicializando um objeto anônimo TextBlob e obtendo o valor polarity para a primeira sentença recebida no corpo da solicitação (neste caso, é a única sentença que estamos passando para análise).
Retornando uma resposta que contém o texto da sentença e o valor calculado para ela polarity.
Iniciando o aplicativo Flask, que estará disponível no endereço 0.0.0.0:5000 (você também pode acessá-lo usando uma estrutura como localhost:5000).

Agora os microsserviços que compõem o aplicativo estão em execução. Eles estão configurados para interagir uns com os outros. Veja como fica o diagrama do aplicativo nesta fase de operação.

Todos os microsserviços que compõem o aplicativo foram colocados em estado operacional.

Agora, antes de prosseguir, abra o aplicativo React em um navegador e tente analisar uma sentença qualquer com ele. Se tudo estiver correto — após clicar no botão Send você verá os resultados da análise abaixo do campo de texto.

Na próxima seção, discutiremos como executar nossos microsserviços em contêineres Docker. Isso é necessário para preparar o aplicativo para ser executado em um cluster Kubernetes.

Contêineres Docker

Kubernetes — é um sistema para automatização do provisionamento, escalonamento e gerenciamento de aplicativos containerizados. Também é conhecido como "orquestrador de contêineres" (container orchestrator). Se o Kubernetes trabalha com contêineres, antes de utilizarmos este sistema, precisamos primeiro adquirir esses contêineres. Mas, primeiro, vamos falar sobre o que são contêineres. Talvez a melhor resposta para a pergunta sobre o que isso é possa ser encontrada em documentação em Docker:

A imagem do contêiner é um pacote leve, autônomo e executável que contém uma aplicação, incluindo tudo o que é necessário para sua execução: código da aplicação, ambiente de execução, ferramentas e bibliotecas do sistema, configurações. Aplicativos containerizados podem ser utilizados em ambientes Linux e Windows, e sempre funcionarão da mesma maneira, independentemente da infraestrutura.

Isso significa que os contêineres podem ser executados em qualquer computador, incluindo servidores de produção, e em qualquer ambiente os aplicativos contidos neles funcionarão da mesma forma.

Para explorar as peculiaridades dos contêineres e compará-las com outras maneiras de executar aplicações, vamos considerar o exemplo da hospedagem de uma aplicação React usando uma máquina virtual e um contêiner.

▍Hospedagem de arquivos estáticos de uma aplicação React utilizando máquinas virtuais

Ao tentar organizar a hospedagem de arquivos estáticos usando máquinas virtuais, encontraremos as seguintes desvantagens:

Uso ineficiente de recursos, uma vez que cada máquina virtual representa um sistema operacional completo.
Dependência da plataforma. O que funciona em um computador local pode não funcionar em um servidor de produção.
Escalonamento lento e exigente em recursos para soluções baseadas em máquinas virtuais.

Servidor web Nginx, hospedando arquivos estáticos, executado em uma máquina virtual

Se, por outro lado, aplicarmos contêineres para resolver a mesma tarefa, em comparação com máquinas virtuais, poderemos notar as seguintes vantagens:

Uso eficiente de recursos: trabalhando com o sistema operacional através do Docker.
Independência de plataforma. Um contêiner que o desenvolvedor pode executar em seu computador funcionará em qualquer lugar.
Implantação leve graças ao uso de camadas de imagem.

Servidor web Nginx servindo arquivos estáticos, executado em um contêiner.

Comparamos máquinas virtuais e contêineres apenas em alguns pontos, mas mesmo isso é suficiente para sentir os pontos fortes dos contêineres. Aqui você pode encontrar detalhes sobre contêineres Docker.

▍Construção da imagem do contêiner para o aplicativo React

O principal bloco de construção do contêiner Docker é o arquivo Dockerfile. No início deste arquivo, faz-se uma anotação sobre a imagem base do contêiner, e depois inclui-se uma sequência de instruções que indicam a ordem de criação do contêiner que atenderá às necessidades de um determinado aplicativo.

Antes de começarmos a trabalhar com o arquivo Dockerfile, vamos nos lembrar do que fizemos para preparar os arquivos do aplicativo React para a implantação no servidor Nginx:

Construção do pacote do aplicativo React (npm run build).
Executar o servidor Nginx.
Copiar o conteúdo do diretório build da pasta do projeto sa-frontend para a pasta do servidor nginx/html.

Abaixo você poderá ver paralelos entre a criação do contêiner e as ações descritas acima, realizadas no computador local.

▍Preparação do arquivo Dockerfile para o aplicativo SA-Frontend

As instruções que serão contidas em Dockerfile para o aplicativo SA-Frontend, consistem em apenas dois comandos. O fato é que o grupo de desenvolvedores do Nginx preparou uma base a imagem para o Nginx, que usaremos para construir nossa imagem. Aqui estão os dois passos que precisamos descrever:

A imagem base deve ser a imagem do Nginx.
O conteúdo da pasta sa-frontend/build deve ser copiado para a pasta da imagem nginx/html.

Se passarmos dessa descrição para o arquivo Dockerfile, ele se parecerá com isso:

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

Como você vê, tudo isso é muito simples, e o conteúdo do arquivo acaba sendo bastante legível e compreensível. Este arquivo diz ao sistema que deve pegar a imagem nginx com tudo o que já existe nela e copiar o conteúdo do diretório build para o diretório nginx/html.

Aqui pode surgir a pergunta sobre como sei para onde exatamente copiar os arquivos da pasta build, ou seja, de onde surgiu o caminho /usr/share/nginx/html. Na verdade, não há nada complicado nisso. O fato é que as informações relevantes podem ser encontradas na descrição da imagem.

▍Criação da imagem e upload para o repositório

Antes de podermos trabalhar com a imagem pronta, precisamos enviá-la para o repositório de imagens. Para isso, utilizaremos a plataforma de cloud gratuita para hospedagem de imagens, o Docker Hub. Neste ponto do trabalho, você precisa fazer o seguinte:

Instalar Docker.
Registrar-se no site do Docker Hub.
Fazer login na conta, executando no terminal o comando do seguinte tipo:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Agora é necessário, através do terminal, ir até o diretório sa-frontend e executar o comando do seguinte tipo:

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

Aqui e adiante em comandos semelhantes $DOCKER_USER_ID deve ser substituído pelo seu nome de usuário no Docker Hub. Por exemplo, essa parte do comando pode parecer assim: rinormaloku/sentiment-analysis-frontend.

Note que esse comando pode ser encurtado, removendo -f Dockerfile, pois na pasta onde estamos executando este comando, esse arquivo já existe.

Para enviar a imagem pronta ao repositório, precisaremos do seguinte comando:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Após sua execução, verifique a lista de seus repositórios no Docker Hub para entender se o envio da imagem para o armazenamento em nuvem foi bem-sucedido.

▍Execução do contêiner

Agora qualquer um pode baixar e executar a imagem, conhecida como $DOCKER_USER_ID/sentiment-analysis-frontend. Para fazer isso, você precisa seguir a seguinte sequência de comandos:

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

Agora o contêiner está em execução e podemos continuar o trabalho, criando outras imagens que precisamos. Mas, antes de prosseguir, vamos entender a construção 80:80, que aparece no comando de execução da imagem e pode parecer confusa.

O primeiro número 80 é o número da porta do host (ou seja, do computador local).
O segundo número 80 é a porta do contêiner, para onde o pedido deve ser redirecionado.

Vamos considerar a seguinte ilustração.

Redirecionamento de portas

O sistema realiza o redirecionamento de pedidos da porta <hostPort> para a porta <containerPort>. Ou seja, um pedido para a porta 80 do computador é redirecionado para a porta 80 do contêiner.

Como a porta 80 está aberta no computador local, você pode acessar o aplicativo a partir deste computador pelo endereço localhost:80. Se o seu sistema não suportar Docker, você pode executar o aplicativo em uma máquina virtual Docker, cujo endereço será <docker-machine ip>:80. Para descobrir o endereço IP da máquina virtual Docker, você pode usar o comando docker-machine ip.

Neste ponto, após o lançamento bem-sucedido do contêiner do aplicativo frontend, você deve ser capaz de abrir sua página no navegador.

▍Arquivo .dockerignore

Ao construir a imagem do aplicativo SA-Frontend, notamos que esse processo pode ser bastante lento. Isso acontece porque o daemon Docker precisa receber o contexto da construção da imagem. O diretório que representa o contexto da construção é definido como o último argumento do comando docker build. No nosso caso, no final deste comando, temos um ponto. Isso resulta na inclusão da seguinte estrutura no contexto de construção:

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

Mas, de todas as pastas presentes aqui, precisamos apenas da pasta build. Carregar qualquer outra coisa é uma perda de tempo. Você pode acelerar a construção indicando ao Docker quais diretórios devem ser ignorados. É para isso que precisamos do arquivo .dockerignore. Para você, se estiver familiarizado com o arquivo .gitignore, a estrutura deste arquivo será, sem dúvida, familiar. Ele lista os diretórios que o sistema de construção da imagem pode ignorar. No nosso caso, o conteúdo deste arquivo é o seguinte:

node_modules
src
public

Arquivo .dockerignore deve estar na mesma pasta que o arquivo Dockerfile. Agora, a construção da imagem levará apenas alguns segundos.

Vamos agora para a imagem do aplicativo Java.

▍Construindo a imagem do contêiner para o aplicativo Java

Você sabe de uma coisa? Você já aprendeu tudo o que precisa para criar imagens de contêineres. É por isso que esta seção será bastante curta.

Abra o arquivo Dockerfile, que está na pasta do projeto sa-webapp. Se você ler o texto deste arquivo, encontrará apenas duas novas construções, começando com as palavras-chave ENV e EXPOSE:

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

A palavra-chave ENV permite declarar variáveis de ambiente dentro de contêineres Docker. Em particular, no nosso caso, ela permite definir a URL para acessar a API do aplicativo que realiza a análise de texto.

A palavra-chave EXPOSE permite que o Docker saiba que a porta deve ser aberta. Vamos usar essa porta ao trabalhar com o aplicativo. Aqui podemos notar que Dockerfile para o aplicativo SA-Frontend não existe tal comando. Isso é necessário apenas para fins de documentação, ou seja, essa construção é destinada a quem vai ler Dockerfile.

A construção da imagem e o envio para o repositório parece exatamente como no exemplo anterior. Se você ainda não está muito seguro de suas habilidades, os comandos correspondentes podem ser encontrados no arquivo README.md na pasta sa-webapp.

▍Construção da imagem do contêiner para o aplicativo Python

Se você olhar o conteúdo do arquivo Dockerfile na pasta sa-logic, você não encontrará nada novo. Os comandos para construir a imagem e enviá-la ao repositório também devem ser familiares para você, mas eles, assim como em outros de nossos aplicativos, podem ser encontrados no arquivo README.md na pasta sa-logic.

▍Testando aplicativos contêinerizados

Você pode confiar em algo que não testou? Eu também não posso. Vamos testar nossos contêineres.

Vamos rodar o contêiner do aplicativo sa-logic e configurá-lo para escutar na porta 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Vamos rodar o contêiner do aplicativo sa-webapp e configurá-lo para escutar na porta 8080. Além disso, precisamos configurar a porta onde o aplicativo Python aguardará solicitações do aplicativo Java, redefinindo a variável de ambiente 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 como descobrir o endereço IP do contêiner ou da máquina virtual Docker, consulte o arquivo README.

Vamos rodar o contêiner do aplicativo sa-frontend:

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

Agora tudo está pronto para acessar no navegador o endereço localhost:80 e testar o aplicativo.

Observe que, se você alterou a porta para sa-webapp, ou se está trabalhando com uma máquina virtual Docker, você precisará editar o arquivo App.js da pasta sa-frontend, substituindo o endereço IP ou o número da porta no método analyzeSentence(), inserindo em vez dos dados obsoletos as informações atuais. Depois disso, você deve reconstruir a imagem e usá-la.

Assim fica o diagrama do nosso aplicativo agora.

Os microserviços estão sendo executados em contêineres

Resultados: por que precisamos de um cluster Kubernetes?

Acabamos de explorar os arquivos Dockerfile, falamos sobre como construir imagens e enviá-las para o repositório Docker. Além disso, aprendemos a acelerar a construção de imagens usando o arquivo .dockerignore. No final, nossos microserviços agora estão sendo executados em contêineres Docker. Aqui pode surgir uma pergunta legítima sobre por que precisamos do Kubernetes. A resposta a essa pergunta será abordada na segunda parte deste material. Enquanto isso, reflita sobre a seguinte questão:
Suponha que nosso aplicativo web para análise de textos se tornou mundialmente popular. A cada minuto, milhões de solicitações chegam a ele. Isso significa que os microserviços sa-webapp e sa-logic estarão sob uma carga imensa. Como escalar os contêineres onde os microserviços estão sendo executados?

Fonte: habr.com