Inicializar um shell da nuvem

A CLI da Red Hat OpenShift Container Platform apresenta comandos para gerenciar seus aplicativos, bem como ferramentas de nível inferior para interagir com cada componente do seu sistema. A CLI está disponível usando o comando oc.

Para evitar a instalação das ferramentas da linha de comandos, a abordagem recomendada é utilizar o IBM Cloud Shell.

O Shell do IBM Cloud é uma área de trabalho de shell baseada em nuvem que é possível acessar por meio de seu navegador. Ele é pré-configurado com a CLI completa do IBM Cloud, além de muitos plug-ins e ferramentas que podem ser usados para gerenciar apps, recursos e infraestruturas.

Nesta etapa, você usará o shell do IBM Cloud e configurará o oc para apontar para o cluster designado a você.

1. Quando o cluster estiver pronto, clique no botão (ao lado da sua conta) no canto superior direito para ativar um Shell de nuvem. Assegure-se de não fechar essa janela/guia.

2. Verifique a versão da CLI do OpenShift:

   oc version
   

   A versão precisa ser, no mínimo, 4.12.x, caso contrário, instale a versão mais recente seguindo estas instruções.

3. Ao listar todos os clusters, você vê a opção Validar seu cluster:

   ibmcloud oc clusters
   

4. Inicialize o ambiente de comando oc substituindo o espaço reservado :

   ibmcloud oc cluster config -c <your-cluster-name> --admin
   

5. Verifique se o comando oc está funcionando:

   oc get projects
   

Criar projeto

Um projeto é uma coleção de recursos gerenciados por uma equipe do DevOps. Um administrador criará o projeto e os desenvolvedores podem criar aplicativos que podem ser construídos e implementados.

1. Navegue para o console da web do Red Hat OpenShift clicando no botão Console da web do OpenShift no Cluster selecionado.
2. Na área de janela de navegação esquerda, na perspectiva Administrador, selecione Início > Projetos para exibir todos os projetos.
3. Crie um novo projeto clicando em Criar projeto. No pop-up, Nomeie o projeto example-health, deixe Exibir nome e Descrição em branco e clique em Criar.
4. A nova página Detalhes do projeto do projeto é exibida. Observe que seu contexto é Administrador > Início > Projetos à esquerda e Projetos > Detalhes do projeto > exemplo de funcionamento na parte superior.

Construir e implementar o aplicativo

1. Alterne da perspectiva do Administrador para o Desenvolvedor. O seu contexto deve ser Desenvolvedor > +Adicionar à esquerda e Projeto: exemplo de funcionamento na parte superior.

   

   .
2. Vamos construir e implementar o aplicativo selecionando Importar de Git.
3. Insira o repositório https://github.com/IBM-Cloud/patient-health-frontend.git no campo de URL do repositório Git.
   • Observe a verificação verde Builder image detected e o Node.js 16 (UBI 8).
   • Observe que a imagem do construtor detectou automaticamente a linguagem Node.js. Se não for detectado, selecione Node.js na lista fornecida.
   • Em Versão da imagem do Builder, deixe a padrão.
   • Nome do aplicativo: exclua todos os caracteres e deixe-o vazio (isso será padronizado para o Nome)
   • Nome: patient-health-frontend.
   • Clique no link Tipo de recurso e escolha DeploymentConfig..
   • Deixe as outras seleções padrão.
4. Clique em Criar na parte inferior da janela para construir e implementar o aplicativo.

Visualizar aplicativo

1. Você deve ver o app recém-implementado. Observe que você está na visualização Topologia do projeto example-health na perspectiva Desenvolvedor. Todos os aplicativos no projeto são exibidos.

2. Selecione o nó patient-health-frontend para apresentar a visualização de detalhes de DeploymentConfig. Observe o DC próximo a patient-health-frontend. Os Pods, Construções, Serviços e Rotas são visíveis.

   

   ..
   • Pods: seus contêineres de aplicativo Node.js
   • Construções: a construção gerada automaticamente que criou uma imagem do Docker por meio do código-fonte Node.js, implementou-a no registro de contêiner do Red Hat OpenShift e iniciou sua configuração de implementação
   • Serviços: informa ao Red Hat OpenShift como acessar seus Pods, agrupando-os como um serviço e definindo a porta na qual atender
   • Rotas: expõe seus serviços para o mundo externo usando o LoadBalancer fornecido pela rede do IBM Cloud

3. Clique em Visualizar logs próximo à construção concluída. Isso mostra o processo usado pelo Red Hat OpenShift para instalar as dependências para o aplicativo Node.js e construir/enviar por push uma imagem do Docker. A última entrada deve ser semelhante a esta:

   Successfully pushed image-registry.openshift-image-registry.svc:5000/example-health/patient-health-frontend@sha256:f9385e010144f36353a74d16b6af10a028c12d005ab4fc0b1437137f6bd9e20a
   Push successful
   

4. Clique de volta na Topologia e selecione seu app novamente.

5. Clique na URL em Rotas para visitar o seu aplicativo. Insira qualquer sequência para nome de usuário e senha, por exemplo, test:test, porque o app está em execução no modo de demonstração.

O app Node.js foi implementado no Red Hat OpenShift Container Platform. Para recapitular:

• O aplicativo "Exemplo de funcionamento" em Node.js foi implementado diretamente do GitHub em seu cluster.
• O aplicativo foi examinado no console Red Hat OpenShift on IBM Cloud.
• Uma Configuração de construção foi criada - uma nova confirmação pode ser construída e implementada clicando em Iniciar construção na seção Construções dos detalhes do aplicativo.

Simular carga no aplicativo

Crie um script para simular carga.

1. Certifique-se de estar conectado ao projeto no qual o app foi implementado.

   oc project example-health
   

2. Recupere a rota pública para acessar seu aplicativo:

   oc get routes
   

   A saída é semelhante a esta, observe seu valor para o Host:

   NAME         HOST/PORT                                                                                                 PATH      SERVICES     PORT       TERMINATION   WILDCARD
   patient-health-frontend   patient-health-frontend-example-health.roks07-872b77d77f69503584da5a379a38af9c-0000.eu-de.containers.appdomain.cloud             patient-health-frontend   8080-tcp                 None
   

3. Defina uma variável com o host:

   HOST=$(oc get routes -o json | jq -r '.items[0].spec.host')
   

4. Verifique o acesso ao aplicativo. Ele gera informações do paciente:

   curl -s -L http://$HOST/info
   

   A saída deve ser semelhante a:

   $ curl -s -L http://$HOST/info
   {"personal":{"name":"Ralph DAlmeida","age":38,"gender":"male","street":"34 Main Street","city":"Toronto","zipcode":"M5H 1T1"},"medications":["Metoprolol","ACE inhibitors","Vitamin D"],"appointments":["2018-01-15 1:00 - Dentist","2018-02-14 4:00 - Internal Medicine","2018-09-30 8:00 - Pediatry"]}
   

5. Execute o script a seguir que enviará solicitações infinitamente para o aplicativo e gerará tráfego:

   while sleep 0.2; do curl --max-time 2 -s -L http://$HOST/info >/dev/null; echo -n "."
   done
   

   Pressione CTRL + c no teclado a fim de parar o script

Red Hat OpenShift on IBM Cloud Criação de log

Como há apenas um pod, a visualização dos logs do aplicativo será direta.

1. Assegure-se de que você esteja na visualização Topologia da perspectiva Desenvolvedor.

2. Selecione o app para acessar o pod.

3. Clique em Visualizar logs ao lado do nome do pod em Pods para ver os logs de streaming do aplicativo em execução. Se você ainda estiver gerando tráfego, você deverá ver mensagens de log para cada solicitação que estiver sendo feita.

   

   .

Terminal do Red Hat OpenShift on IBM Cloud

Uma das grandes coisas sobre o Kubernetes é a capacidade de depurar rapidamente seus pods do aplicativo com terminais SSH. Isso é ótimo para o desenvolvimento, mas geralmente não é recomendado em ambientes de produção. O site Red Hat OpenShift torna isso ainda mais fácil, permitindo que você inicie um terminal diretamente no painel.

1. Alterne da guia Logs para a guia Terminal.
2. Execute os comandos Shell a seguir:

Red Hat OpenShift on IBM Cloud Monitoramento

Ao implementar novos apps, fazer mudanças na configuração ou simplesmente inspecionar o estado de seu cluster, o painel do escopo do projeto fornece insights claros do Desenvolvedor.

1. Acesse o painel na perspectiva do desenvolvedor clicando em Observar no menu do lado esquerdo.
2. Você também pode mergulhar em um pouco mais profundo clicando na aba Eventos. Os Eventos são úteis para identificar a linha do tempo dos eventos e para localizar possíveis mensagens de erro. Ao rastrear o estado de um novo lançamento, gerenciar ativos existentes ou até mesmo algo simples, como expor uma rota, a visualização Eventos é crítica na identificação da linha de tempo de atividade. Isso se torna ainda mais útil ao considerar que vários operadores podem estar trabalhando em um único cluster.

Quase todas as ações no Red Hat OpenShift resultam no disparo de um evento nessa visualização. Como ele é atualizado em tempo real, é uma ótima maneira de rastrear mudanças no estado.

Painéis

Red Hat OpenShift vem com dashboards predefinidos para monitorar seus projetos.

1. Comece alternando da perspectiva Desenvolvedor para a perspectiva Administrador:
2. Navegue até Observar > Painéis na barra esquerda.
3. Selecione Kubernetes/Recursos de computação/Espaço de nomes (Pods) na lista suspensa e Espaço de nomes para exemplo de funcionamento.
4. Observe o uso de CPU e memória para seu aplicativo. Em ambientes de produção, isso é útil para identificar a quantia média de CPU ou de memória usada por seu aplicativo, especialmente porque é possível flutuar durante o dia. O ajuste automático de escala é uma maneira de manipular as flutuações e será demonstrado um pouco mais tarde.

Métricas

Red Hat OpenShift fornece uma interface web para executar consultas e examinar as métricas visualizadas em um plot. Essa funcionalidade fornece uma visão geral extensiva do estado do cluster e permite solucionar problemas.

1. Navegue até Observe> Metrics.

2. Insira a expressão a seguir e clique em Executar consultas. O valor e o gráfico associado deverão ser exibidos com a consulta.

   sum(container_cpu_usage_seconds_total{container="patient-health-frontend"})
   

   

Ativar limites de recurso

Antes de ajustar automaticamente a escala, os limites máximos de recursos de CPU e de memória devem ser estabelecidos.

Os painéis anteriores mostraram que a carga estava consumindo algo entre ".002" e ".02" núcleos. Isso se traduz em 2 a 20 "milinúcleos". Para ser seguro, vamos aumentar o limite superior para 30 milinúcleos. Além disso, os dados mostraram que o app consome cerca de 25-65 MB de RAM. As etapas a seguir configurarão os limites de recursos em DeploymentConfig

1. Certifique-se de que o script para gerar tráfego esteja em execução.

2. Alterne para a perspectiva Administrador.

3. Navegue até Cargas de Trabalho > DeploymentConfigs.

4. Selecione o projeto exemplo de funcionamento.

5. No menu Ações (os três pontos verticais) de patient-health-frontend, escolha Editar ImplanmentConfig.

   

6. Na Visualização do YAML, localize a seção spec > template > spec > containers e inclua os limites de recursos a seguir nos recursos vazios. Substitua o resources {} e assegure-se de que o espaçamento esteja correto -- o YAML usa indentação estrita.

             resources:
               limits:
                 cpu: 30m
                 memory: 100Mi
               requests:
                 cpu: 3m
                 memory: 40Mi
   

   Aqui está um fragmento depois de você ter feito as mudanças:

          ports:
            - containerPort: 8080
              protocol: TCP
          resources:
            limits:
              cpu: 30m
              memory: 100Mi
            requests:
              cpu: 3m
              memory: 40Mi
          terminationMessagePath: /dev/termination-log
   

7. Salvar para aplicar as mudanças.

8. Verifique se o controlador de replicação foi alterado navegando para a guia Eventos:

   

   ..

Ativar o escalador automático

Agora que os limites de recursos estão configurados, o ajustador de escala automático do pod pode ser ativado.

Por padrão, o escalador automático permite escalar com base na CPU ou na memória. Os pods são balanceados entre o número mínimo e o número máximo de pods especificados. Com o escalador automático, os pods são criados ou excluídos automaticamente para assegurar que o uso médio de CPU dos pods esteja abaixo do destino de solicitação da CPU, conforme definido. Em geral, você provavelmente desejará começar o ajuste de escala quando chegar perto de 50 a 90% de uso da CPU de um pod. Em nosso caso, 1% pode ser usado com a carga que está sendo fornecida.

1. Navegue até a perspectiva Administrador, Cargas de trabalho > HorizontalPodAutoscalers e, em seguida, clique em Criar HorizontalPodAutoscaler.

   

   Substitua o conteúdo do editor por este yaml:

   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: patient-hpa
     namespace: example-health
   spec:
     scaleTargetRef:
       apiVersion: apps.openshift.io/v1
       kind: DeploymentConfig
       name: patient-health-frontend
     minReplicas: 1
     maxReplicas: 10
     metrics:
       - type: Resource
         resource:
           name: cpu
           target:
             averageUtilization: 1
             type: Utilization
   

2. Clique em Criar.

Testar o escalador automático

Se você não estiver executando o script para simular carga, o número de pods deverá ficar em 1.

1. Confira abrindo a página Visão geral da configuração de implementação. Clique em Cargas de trabalho > DeploymentConfigs e em patient-health-frontend e selecione o painel Detalhes.

2. Comece a simular a carga (consulte a seção anterior para simular a carga no aplicativo).

   

   Pode levar alguns minutos para o escalador automático fazer ajustes.

É isso! Agora você tem um aplicativo front-end Node.js altamente disponível e dimensionado automaticamente. Red Hat OpenShift está dimensionando automaticamente os pods do aplicativo, pois o uso da CPU dos pods excedeu em muito 1% do limite de recursos, 30 milicores.

Fazendo o ajuste automático de escala na linha de comandos

Também é possível excluir e criar recursos, como escaladores automáticos, com a linha de comandos.

1. Comece verificando se o contexto é seu projeto:

   oc project example-health
   

2. Obtenha o escalador automático criado anteriormente:

   oc get hpa
   

3. Exclua o escalador automático criado anteriormente:

   oc delete hpa/patient-hpa
   

4. Crie um novo escalador automático com um máximo de nove pods:

   oc autoscale deploymentconfig/patient-health-frontend --name patient-hpa --min 1 --max 9 --cpu-percent=1
   

5. Revisite a página de detalhes Cargas de trabalho > DeploymentConfigs para obter a implementação patient-health-frontend e veja ela trabalhando.

Ativar o IBM Cloud Operator

Vamos entender exatamente como os Operadores funcionam. No primeiro exercício, você usou um construtor para implementar um aplicativo simples usando um DeploymentConfig um tipo de recurso padrão que vem com Red Hat OpenShift. Uma definição de recurso personalizado permite que você crie tipos de recursos que não vêm pré-instalados no site Red Hat OpenShift on IBM Cloud, como o serviço IBM Cloud. Os operadores gerenciam o ciclo de vida de recursos e criam Descritores de recurso customizado, CRDs, permitindo gerenciar recursos customizados do modo nativo "Kubernetes".

1. Na perspectiva Administrador, clique em Operadores > OperatorHub.
2. Localize o IBM Cloud Operator e clique em Instalar.
3. Mantenha as opções padrão e clique em Instalar.
4. Após alguns segundos installed operator - ready for use deve ser exibido.

Criar um serviço do Cloudant e ligar usando os CRDs

Clique para abri-lo. Role para baixo até a seção Pré-requisitos.

Uma chave de API com as permissões apropriadas para criar um banco de dados IBM Cloudant é necessária nesta seção. A chave de API será armazenada em um recurso Segredo do Kubernetes. Isso precisará ser criado usando o shell. Há instruções na seção Pré-requisitos do operador instalado. Etapas:

1. Use os mesmos grupo de recursos e região que estão associados ao seu cluster.

   ibmcloud target -g <resource_group> -r <region>
   

   Para ver os grupos de recursos em sua conta, execute o comando ibmcloud resource groups

2. Verifique se o grupo de recursos e a região correspondem ao cluster. O comando a seguir deve retornar o seu cluster

   ibmcloud oc cluster ls
   

A saída é algo semelhante a isto:

$ ibmcloud oc cluster ls
OK
Name      ID                     State    Created        Workers   Location   Version                  Resource Group Name   Provider
osmicro   ck68svdd0vvcfs6ad9ag   normal   18 hours ago   2         Dallas     4.12.26_1562_openshift   default               vpc-gen2

3. Use o script auxiliar fornecido pela IBM para criar os recursos a seguir:

   • Chave de API do IBM Cloud que representa você e suas permissões para usar o IBM Cloud
   • O Segredo do Kubernetes denominado secret-ibm-cloud-operator no namespace default. Esse segredo tem as chaves api-key e region. O operador usará esses dados para criar a instância de serviço do cloudant.
   • O recurso ConfigMap do Kubernetes com o nome config-ibm-cloud-operator no namespace default para manter a região e o grupo de recursos

   Use o comando curl fornecido:

   curl -sL https://raw.githubusercontent.com/IBM/cloud-operators/master/hack/configure-operator.sh | bash
   

4. No console da web do Red Hat OpenShift, clique em Criar serviço na guia Serviço em Operadores instalados da página IBM Cloud Operator e selecione Visualização do YAML para abrir o editor yaml.

5. Faça as substituições sugeridas quando serviceClass for cloudantnosqldb; o plano poderá ser Lite ou Standard (apenas um plano Lite é permitido por conta). Substitua<your-initials>:

   apiVersion: ibmcloud.ibm.com/v1
   kind: Service
   metadata:
     annotations:
      ibmcloud.ibm.com/self-healing: enabled
     name: <your-initials>-cloudant-service
     namespace: example-health
   spec:
     serviceClass: cloudantnosqldb
     plan: standard
   

6. Clique em Criar para criar uma instância de banco de dados do IBM Cloudant. Seu contexto deve ser Operadores > Operadores instalados > IBM Cloud Operator na perspectiva do Administrador com o Projeto: example-health no painel Serviço.

7. Clique no serviço que acabou de ser criado, -cloudant-service e, com o tempo, o campo de estado mudará de provisionamento para Online, o que significa que ele está pronto para funcionar.

8. Crie um recurso de Ligação e um recurso Secreto para o recurso de Serviço do Cloudant recém-criado. Navegue novamente para a guia Operadores > Operadores instalados > IBM Cloud Operator > Ligação. Abra a guia Ligação, clique em Criar ligação e selecione Visualização do YAML. Crie um cloudant-binding associado com o serviceName <your-initials>-cloudant-service, (esse é o nome fornecido para o Serviço criado anteriormente).

   apiVersion: ibmcloud.ibm.com/v1
   kind: Binding
   metadata:
     name: cloudant-binding
     namespace: example-health
   spec:
     serviceName: <your-initials>-cloudant-service
   

9. Opcionalmente, aprofunde-se um pouco mais para entender o relacionamento entre os recursos do Red Hat OpenShift: Serviço, Ligação do serviço, Segredo da ligação e os recursos do IBM Cloud: Serviço, Instância do serviço e as Credenciais de serviço da instância. Usando o shell de nuvem:

   ibmcloud resource service-instances --service-name cloudantnosqldb
   

   YOURINITIALS=<your-initials>
   

   ibmcloud resource service-instance $YOURINITIALS-cloudant-service
   

   ibmcloud resource service-keys --instance-name $YOURINITIALS-cloudant-service --output json
   

   A saída é algo semelhante a isto:

   youyou@cloudshell:~$ ibmcloud resource service-instances --service-name cloudantnosqldb
   Retrieving instances with type service_instance in all resource groups in all locations under ..
   OK
   Name                           Location   State    Type
   <your-initials>-cloudant-service               us-south   active   service_instance
   youyou@cloudshell:~$ ibmcloud resource service-instance <your-initials>-cloudant-service
   Retrieving service instance <your-initials>-cloudant-service in all resource groups under ...
   OK
   
   Name:                  <your-initials>-cloudant-service
   ID:                    crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET
   GUID:                  SECRET
   Location:              us-south
   Service Name:          cloudantnosqldb
   Service Plan Name:     standard
   Resource Group Name:   Default
   State:                 active
   Type:                  service_instance
   Sub Type:
   Created at:            2020-05-06T22:39:25Z
   Created by:            youyou@us.ibm.com
   Updated at:            2020-05-06T22:40:03Z
   Last Operation:
                       Status       create succeeded
                       Message      Provisioning is complete
                       Updated At   2020-05-06 22:40:03.04469305 +0000 UTC
   
   youyou@cloudshell:~$ ibmcloud resource service-keys --instance-name $YOURINITIALS-cloudant-service --output json
   [
       {
           "guid": "01234560-902d-4078-9a7f-20446a639aeb",
           "id": "crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET",
           "url": "/v2/resource_keys/01234560-902d-4078-9a7f-20446a639aeb",
           "created_at": "2020-05-06T23:03:43.484872077Z",
           "updated_at": "2020-05-06T23:03:43.484872077Z",
           "deleted_at": null,
           "name": "cloudant-binding",
           "account_id": "0123456789507a53135fe6793c37cc74",
           "resource_group_id": "01234567836d49029966ab5be7fe50b5",
           "source_crn": "crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET",
           "state": "active",
           "credentials": {
               "apikey": "SECRET",
               "host": "SECRET",
               "iam_apikey_description": "Auto-generated for key SECRET",
               "iam_apikey_name": "cloudant-binding",
               "iam_role_crn": "SECRET",
               "iam_serviceid_crn": "SECRET",
               "password": "SECRET",
               "port": 443,
               "url": "https://01234SECRET",
               "username": "01234567-SECRET"
           },
           "iam_compatible": true,
           "resource_instance_url": "/v2/resource_instances/SECRET",
           "crn": "crn:v1:bluemix:public:cloudantnosqldb:us-south:a/0123456789507a53135fe6793c37cc74:SECRET"
       }
   ]
   

Implementar o app Node.js do banco de dados back-end do paciente

Agora você criará o app Node.js que preencherá o seu BD Cloudant com dados do paciente. Ele também entregará dados para o aplicativo front-end implementado anteriormente.

1. Certifique-se de que seu contexto seja o projeto example-health:

   oc project example-health
   

2. O comando new-app a seguir fará uma configuração de construção e uma configuração de implementação. A seguir, uma demonstração da chamada da CLI do aplicativo de inclusão (lembre-se de usar o console da GUI para o front-end):

   oc new-app --name=patient-health-backend --as-deployment-config registry.access.redhat.com/ubi9/nodejs-20-minimal:latest~https://github.com/IBM-Cloud/patient-health-backend
   

3. No console e na visualização Topologia da perspectiva do Desenvolvedor, abra o app patient-health-backend e aguarde a construção ser concluída. Observe que a inicialização do Pod está falhando. Clique nos logs do Pod para ver:

   > node app.js
   
   /opt/app-root/src/app.js:23
            throw("Cannot find Cloudant credentials, set CLOUDANT_URL.")
            ^
   Cannot find Cloudant credentials, set CLOUDANT_URL.
   

4. Vamos corrigir isso configurando a variável de ambiente do DeploymentConfig para o segredo cloudant-binding criado anteriormente na seção de ligação do operador. Navegue até a configuração de implementação para o aplicativo patient-health-backend clicando no aplicativo e, em seguida, selecionando o nome ao lado de DC:

   

5. Acesse a guia Ambiente, clique em Incluir por meio do ConfigMap ou Segredo e crie uma nova variável de ambiente denominada CLOUDANT_URL. Escolha o segredo cloudant-binding e, em seguida, escolha url para a Chave. Clique em Salvar.

   

6. Volte para a guia Topologia e clique em patient-health-backend. Verifique a seção Pods, que deve indicar Em execução em breve. Clique em Visualizar logs ao lado do pod em execução e observe os bancos de dados criados.

Configurar o app Patient Health Frontend para usar o app Patient Health Backend

O aplicativo patient-health-frontend tem uma variável de ambiente para a URL de microsserviço de back-end.

1. Configure a variável de ambiente API_URL como default no front-end DeploymentConfig. Navegue até a configuração de implementação para o app patient-health-frontend clicando no app front-end na visualização Topologia e selecionando o nome ao lado próximo a DC:

2. Acesse a guia Ambiente e, na seção Valores únicos (env), inclua um nome API_URL e um valor default. Clique em Salvar e, em seguida, em Recarregar. Isso resultará em uma conexão com http://patient-health-backend:8080/, que será possível verificar examinando os logs do pod. É possível verificar se esta é a porta correta varrendo a saída Pod Template / Containers / Port deste comando:

   oc describe dc/patient-health-backend
   

Seu aplicativo agora é suportado pelos dados mock do paciente no BD Cloudant. Agora é possível efetuar login usando qualquer ID do usuário/senha no banco de dados do Cloudant, com "opall:opall".

1. Em um aplicativo do mundo real, essas senhas não devem ser armazenadas como texto sem formatação. Para revisar os pacientes (e logins alternativos) no banco de dados do Cloudant, navegue até seus services na Lista de recursos da IBM Cloud. Clique em -cloudant-service.
2. Ative o painel do Cloudant clicando no botão Ativar painel e, em seguida, clique no banco de dados patients.
3. Clique nos diferentes pacientes com os quais você pode fazer login.

Visualizar visualizações e painéis de monitoramento predefinidos

Use visualizações e painéis para monitorar sua infraestrutura, aplicativos e serviços. É possível usar painéis predefinidos. Também é possível criar painéis customizados por meio da IU da web ou programaticamente. É possível fazer backup e restaurar painéis usando scripts Python.

A tabela a seguir lista os diferentes tipos de painéis predefinidos:

Visualizar o painel do Monitoring

1. Navegue para os clusters do Red Hat OpenShift on IBM Cloud e observe os clusters do Red Hat OpenShift
2. Clique em seu cluster e verifique se a guia Visão geral à esquerda está selecionada
3. Na seção Integrações ao lado de Monitoramento, selecione o botão Ativar.

Os dados iniciais podem NÃO estar disponíveis nas instâncias do Monitoring recém-criadas.

• Após alguns minutos, os dados brutos serão exibidos
• Após cerca de uma hora, a indexação fornecerá o detalhe necessário para continuar com este tutorial

1. Na seção Dashboards, selecione Kubernetes > Pod Status & Performance para visualizar as métricas brutas de todas as cargas de trabalho em execução no cluster.
2. Configure o filtro namespace para exemplo-saúde para se concentrar nos pods de sua aplicação.
3. Em Painéis, na área de janela esquerda, expanda Aplicativos em Modelos de painel. Em seguida, selecione HTTP para obter uma visualização global da carga de HTTP do cluster.

Explorar o cluster e a capacidade de nó

1. Selecione Painéis e confira os dois modelos de painel:

   • Contêineres > Uso de recurso de contêiner
   • Infraestrutura de host > Uso de recurso de host

2. Selecione o modelo Kubernetes > Pod Rightsizing & Workload Capacity Optimization. Este painel ajuda você a otimizar sua infraestrutura e melhor controlar o gasto de cluster, por garantir que os pods sejam dimensionados corretamente. Entenda se você pode liberar recursos, reduzindo as solicitações de memória e / ou CPU.

Explore o aplicativo

1. Selecione Painéis e o modelo Kubernetes > Status da carga de trabalho e desempenho.

   Um painel detalhado que mostra todos os pods no cluster

2. Crie um painel customizado e, em seguida, defina o escopo dele para um namespace específico.

   • Na parte superior direita, clique em Copiar para meus painéis e nomeie-o Workload Status & Performanceapp example-health
   • Clique em Criar e abrir para criar seu próprio painel..
   • Edite o escopo do painel.
   • Configure o filtro para kube_namespace_name. is, example-health.
   • Clique em Salvar.

   O painel agora mostra informações focadas no namespace example-health.

   Role para baixo até os TimeCharts de solicitações HTTP, latência, erro, ... para entender o desempenho do aplicativo.

   

Localize mais sobre o IBM Cloud Monitoring na documentação da IBM Cloud.