Implementar um aplicativo front-end

1. Para implementar um novo aplicativo Code Engine, execute o comando a seguir; fornecendo um nome de serviço frontend e a imagem de contêiner pré-construído como parâmetro para a sinalização de --image.

   ibmcloud code-engine application create --name frontend --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-frontend
   

   Depois de executar esse comando, uma saída com uma URL para o seu aplicativo deverá ser exibida. Ele deve ser semelhante a: https://frontend.305atabsd0w.us-south.codeengine.appdomain.cloud. Copie ou anote esse URL do aplicativo para a próxima etapa. Com apenas esses dois dados (nome do aplicativo e nome da imagem), Code Engine implantou seu aplicativo e cuidará das complexidades de configurá-lo e gerenciá-lo para você.

   O código-fonte do aplicativo usado para criar as imagens do contêiner está disponível em um repositório GitHub para sua referência. Se você deseja construir as imagens de contêiner por meio de código-fonte e enviar por push as imagens para um Registro de Contêiner privado, siga as instruções aqui.

2. Abra o URL do aplicativo da etapa anterior em um navegador para ver um resultado semelhante a este:

   

   Execute o comando ibmcloud code-engine application get -n frontend para ver os detalhes do aplicativo. Detalhes como o ID, as informações sobre o projeto, a idade do aplicativo, a URL para acessar o aplicativo, uma URL do console para acessar a configuração do seu aplicativo, a alocação de imagens e recursos, além de diversas revisões, condições e o tempo de execução para o seu aplicativo deverão ser vistos. Como você tem somente uma revisão, verá que 100% do tráfego vai para a revisão mais recente. Também é possível verificar o número de instâncias e o status delas.

3. Para solucionar problemas e verificar os registros do seu aplicativo, execute o seguinte comando substituindo <INSTANCE_NAME> pelo nome de uma das instâncias do comando ibmcloud code-engine application get -n frontend.

   Se você não vir nenhuma instância em execução, certifique-se de abrir novamente o URL do aplicativo a partir da etapa 2.

   ibmcloud code-engine application logs --instance <INSTANCE_NAME>
   

   Se o aplicativo estiver em execução, você deverá ver backend URL: undefined e App atendendo na porta 8080. Mais adiante no tutorial, você conectará esse aplicativo de front-end ao nosso aplicativo back-end

Parabéns. O aplicativo da web acaba de ser implementado no Code Engine com um comando simples e também sem precisar conhecer as complexidades do Kubernetes, tais como pods, implementações, serviços e ingresso.

Escalar o aplicativo

Quando o aplicativo foi criado com o comando e application create, foram transmitidos somente uma imagem para uso e um nome para o aplicativo. Embora essa seja a quantidade mínima de informações para implantar um aplicativo, há vários outros botões sobre os quais você tem controle. Entre outros, é possível configurar o número de solicitações que podem ser processadas simultaneamente por instância, a quantia de CPU para a instância do aplicativo, a quantia de memória configurada para a instância do aplicativo, as variáveis de ambiente para o aplicativo, o número máximo e o mínimo de instâncias que podem ser usadas para este aplicativo e a porta na qual o aplicativo atende às solicitações.

A maioria desses valores tem um padrão configurado caso nada seja fornecido como uma opção ao criar o aplicativo. Como não fornecemos um valor, o Code Engine implementou o nosso aplicativo com uma escala máxima padrão de 10, o que significa que ele será escalado somente até 10 instâncias. A escala mínima padrão é zero, de modo que, quando nosso aplicativo não estiver mais em uso, ele escalará de volta para zero.

1. Para verificar os recursos de dimensionamento automático de Code Engine, podemos usar um gerador de carga para executar solicitações em nosso serviço. O script de shell a seguir simula um carregamento básico de 3000 solicitações

   1. Abra uma janela do terminal local (shell).

   2. Crie uma variável de shell para o URL do aplicativo de front-end da etapa acima.

      export APPURL=<frontend-application-url>
      

   3. Execute o seguinte script para gerar algum carregamento. Você pode repetir para criar mais tráfego.

      seq 1 3000 | xargs -n1 -P300  curl -s  $APPURL -o /dev/null
      

2. Em sua sessão Cloud Shell nas seções anteriores, execute o comando abaixo para ver a contagem de instância (pod) incrementando como parte do ajuste automático de escala.

   ibmcloud code-engine application get -n frontend
   

   Por padrão, o número máximo de solicitações que podem ser processadas simultaneamente por instância é de 10 levando ao ajuste automático de escala e esse valor pode ser mudado usando a sinalização --concurrency or -cn com o comando application update.

3. Para não permitir que até 10 instâncias sejam criadas, é possível ajustar a escala máxima para ser um número inferior. Embora o seu aplicativo sem servidor possa ter a capacidade aumentada facilmente, é possível depender de um serviço de recebimento de dados, tal como um banco de dados SQL, que pode manipular somente um número limitado de conexões ou outra API de taxa limitada. Vamos tentar limitar o número de instâncias para este aplicativo front-end.

   ibmcloud code-engine application update --name frontend --max-scale 5
   

4. Uma vez que a geração de carregamento esteja interrompida, aguarde alguns minutos para ver as instâncias finalizarem, diminuindo eventualmente a capacidade para zero instâncias.

5. Em sua janela local com o comando load generator, execute o script novamente para criar solicitações no app. Na sessão Cloud Shell, execute o comando ibmcloud code-engine application get -n frontend para ver a contagem de instâncias aumentando para 5.

   Expected Output:

   Name                                        Revision        Running  Status   Restarts  Age
   frontend-00002-deployment-77d5fbfb5d-7zpfl  frontend-00002  3/3      Running  0         70s
   frontend-00002-deployment-77d5fbfb5d-kv6rn  frontend-00002  3/3      Running  0         69s
   frontend-00002-deployment-77d5fbfb5d-mhlwn  frontend-00002  3/3      Running  0         68s
   frontend-00002-deployment-77d5fbfb5d-qkjmd  frontend-00002  3/3      Running  0         67s
   frontend-00002-deployment-77d5fbfb5d-zpr9n  frontend-00002  3/3      Running  0         85s
   

Implementar um aplicativo back-end e testar a conexão

1. Para implementar um novo aplicativo back-end para armazenar seus arquivos de texto no IBM Cloud Object Storage, execute este comando

   ibmcloud code-engine application create --name backend --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-backend --cluster-local
   

   O sinalizador --cluster-local instruirá Code Engine a manter o ponto de extremidade desse aplicativo privado, o que significa que ele só estará disponível no projeto. Isso é frequentemente usado para propósitos de segurança. Nesse caso, não há razão para expor o aplicativo back-end com um terminal público, uma vez que ele não será acessado de fora do cluster.

2. Copie e salve o endpoint interno URL ) da saída para usá-lo no próximo comando. Ele se parecerá com o seguinte:

   BACKEND_PRIVATE_URL=http://backend.xxxxxx
   

   Você pode executar o comando ibmcloud code-engine application get -n backend para verificar o status e os detalhes do aplicativo de backend que inclui o URL.

3. O aplicativo front-end usa uma variável de ambiente (BACKEND_URL) para saber onde o aplicativo back-end está hospedado. Agora, é necessário atualizar o aplicativo front-end para configurar esse valor para apontar para o terminal do aplicativo back-end.

   ibmcloud code-engine application update --name frontend --env BACKEND_URL=$BACKEND_PRIVATE_URL
   

   A sinalização --env poderá aparecer quantas vezes forem desejadas, se for necessário configurar mais de uma variável de ambiente. Essa opção também poderia ter sido usada no comando ibmcloud code-engine application create para o aplicativo front-end se o valor dele fosse conhecido naquele momento. Saiba mais lendo o tópico da documentação Trabalhando com variáveis de ambiente.

4. Efetue uma atualização rígida da URL front-end no navegador para testar a conexão com o aplicativo back-end. Deverá ser exibida uma página com uma opção para fazer upload de um arquivo de texto (.txt) e também uma mensagem de erro do aplicativo back-end, já que o back-end ainda não está conectado com os serviços IBM Cloud necessários para armazenar e processar os arquivos de texto. Clicar em Upload de arquivo de texto também deve mostrar uma mensagem de erro semelhante.

Provisionar os serviços Object Storage e Natural Language Understanding

1. Crie uma instância do Object Storage

   1. Selecione o plano Lite ou o plano Padrão se você já tiver uma instância de serviço do Object Storage em sua conta.
   2. Configure Service name para your-initials-code-engine-cos.
   3. Selecione o grupo de recursos onde você criou o projeto Code Engine.
   4. Clique em Criar.
   5. Capture o nome do serviço em uma variável shell:

      COS_INSTANCE_NAME=your-initials-code-engine-cos
      

2. Em Criar depósito, clique em Criar depósito e, em seguida, em Criar um depósito customizado, selecione Criar.

   Ao criar compartimentos ou adicionar objetos, evite o uso de informações de identificação pessoal (PII). Observação: PII são informações que podem identificar qualquer usuário (pessoa física) por nome, local ou qualquer outro meio.

   1. Insira Nome do depósito exclusivo como <your-initials>-bucket-code-engine.
   2. Selecione um Local, onde você criou o projeto Code Engine.
   3. Selecione a classe de armazenamento Smart Tier.
   4. Clique em Criar depósito.
   5. Capture o nome do balde em uma variável de shell:

      COS_BUCKETNAME=your-initials-bucket-code-engine
      

3. Na página do depósito..

   1. Clique na guia Configuration (Configuração )
   2. O terminal Direct manterá dados no IBM Cloud. Capture o terminal direto em uma variável de shell. Na região de Dallas, sul dos EUA, pode ser:

      COS_ENDPOINT=s3.direct.us-south.cloud-object-storage.appdomain.cloud
      

4. Crie uma instância de Natural Language Understanding

   1. Selecione um local e selecione o plano Lite.
   2. Configure o Nome de serviço para code-engine-nlu e selecione o grupo de recursos no qual você criou o projeto Code Engine.
   3. Leia o contrato de licença e, em seguida, marque Eu li e concordo com os seguintes contratos de licença:.
   4. Clique em Criar.
   5. Capture o nome do serviço em uma variável shell:

      NLU_INSTANCE_NAME=YourServiceName
      

Ligar o serviço Object Storage ao aplicativo back-end

Agora, será necessário transmitir as credenciais para a instância do IBM Cloud Object Storage que acabou de ser criada em seu aplicativo back-end. Você fará isso vinculando o serviço Object Storage ao seu aplicativo, o que adiciona automaticamente as credenciais de um serviço às variáveis de ambiente do seu aplicativo ou trabalho.

1. Crie uma ligação para o serviço Object Storage como um prefixo COS para facilidade de uso em seu aplicativo. O comando bind cria uma credencial de serviço na instância de serviço e a partir daí inicializa as variáveis de ambiente do aplicativo com as credenciais. Cada associação de serviço pode ser configurada para usar um prefixo de variável de ambiente personalizado usando o sinalizador --prefix.

   ibmcloud code-engine application bind --name backend --service-instance $COS_INSTANCE_NAME --role Writer --prefix COS
   

2. Também será necessário fornecer ao aplicativo o nome do seu depósito no qual deseja armazenar os arquivos de texto, bem como seu terminal COS. Ambos foram definidos em uma etapa anterior. O terminal para us-south para a camada Inteligente é s3.direct.us-south.cloud-object-storage.appdomain.cloud

   Defina um configmap para manter o nome do bucket e o endpoint, pois as informações não são confidenciais. ConfigMaps são um objeto do Kubernetes, que permitem desacoplar artefatos de configuração do conteúdo da imagem para manter os aplicativos conteinerizados móveis. É possível criar esse configmap por meio de um arquivo ou de um par chave-valor. Por enquanto, usaremos um par chave-valor com a sinalização --from-literal. Verifique se você capturou estes anteriores e crie o configmap:

   echo bucket $COS_BUCKETNAME endpoint $COS_ENDPOINT
   

   ibmcloud code-engine configmap create --name backend-configuration --from-literal=COS_BUCKETNAME=$COS_BUCKETNAME --from-literal=COS_ENDPOINT=$COS_ENDPOINT
   

3. Com o configmap definido, agora é possível atualizar o aplicativo back-end solicitando ao Code Engine para configurar variáveis de ambiente no tempo de execução do aplicativo com base nos valores no configmap. Atualize o aplicativo back-end com o comando a seguir

   ibmcloud code-engine application update --name backend --env-from-configmap backend-configuration
   

   Para criar um segredo, é necessário usar a sinalização --env-from-secret. Os dois segredos e configmaps são "mapas", portanto, as variáveis de ambiente configuradas terão um nome correspondente à "chave" de cada entrada nesses mapas e os valores das variáveis de ambiente serão o valor dessa "chave".

4. Para verificar se o aplicativo back-end está atualizado com a ligação e o configmap. É possível executar o comando abaixo e verificar as seções Service Bindings e Environment Variables na saída

   ibmcloud code-engine application get --name backend
   

5. Acesse a IU de front-end e faça upload de arquivos de texto para análise de texto. Os arquivos transferidos por upload deverão ser exibidos com a tag Not analyzed neles.

Criar uma tarefa

Os trabalhos, diferentemente dos aplicativos que reagem às solicitações HTTP recebidas, devem ser usados para executar imagens de contêineres que contêm um executável projetado para ser executado uma vez e depois sair. Ao criar uma job, é possível especificar informações de configuração de carga de trabalho que são usadas a cada vez que a tarefa é executada. É possível criar uma tarefa por meio do console ou com a CLI.

Essa tarefa lerá os arquivos de texto do IBM Cloud Object Storage e, em seguida, os analisará usando o serviço Natural Language Understanding. Ela precisará ter acesso a credenciais de serviço para os dois serviços.

1. Execute o seguinte comando para criar um trabalho,

   ibmcloud code-engine job create --name backend-job --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-backend-job --env-from-configmap backend-configuration
   

   É possível configurar a versão do serviço Natural Language Understanding usando a sinalização --env. Para o versionamento, verifique este link

Ligar os serviços IBM Cloud à tarefa

1. Vamos criar uma ligação para o serviço Object Storage com um prefixo COS_JOB a ser usado com as tarefas para ler os arquivos transferidos por upload e para armazenar os resultados.

   ibmcloud code-engine job bind --name backend-job --service-instance $COS_INSTANCE_NAME --role Writer --prefix COS_JOB
   

2. Da mesma forma, vamos ligar o serviço Natural Language Understanding com um prefixo NLU_JOB para analisar os arquivos de texto transferidos por upload.

   ibmcloud code-engine job bind --name backend-job --service-instance $NLU_INSTANCE_NAME --role Writer --prefix NLU_JOB
   

3. Para verificar se a tarefa está atualizada com a ligação e o configmap. É possível executar o comando abaixo e verificar as seções Service Bindings e Environment Variables na saída

   ibmcloud code-engine job get --name backend-job
   

Executar a tarefa

1. Para executar um trabalho com a configuração criada acima, use o comando jobrun submit,

   ibmcloud code-engine jobrun submit --name backend-jobrun --job backend-job
   

   Ao executar uma tarefa, é possível substituir muitas das variáveis definidas na configuração da tarefa. Para verificar as variáveis, execute ibmcloud code-engine jobrun submit --help.

2. Para verificar o status do jobrun, execute o comando a seguir

   ibmcloud code-engine jobrun get --name backend-jobrun
   

3. Os logs podem ser exibidos:

   ibmcloud code-engine jobrun logs --follow --name backend
   

4. Na IU front-end, clique no botão Atualizar (ao lado de Fazer upload de arquivo de texto) para ver as Palavras-chave e o JSON para cada um dos arquivos de texto transferidos por upload. A tag em cada arquivo deve agora mudar para Analyzed.

5. Faça upload de novos arquivos ou exclua um arquivo individual clicando no ícone Excluir, reenvie o jobrun com o comando abaixo e pressione o botão Atualizar para ver os resultados.

   ibmcloud code-engine jobrun resubmit --jobrun backend-jobrun
   

Automatizar a execução da tarefa

Em vez de executar a tarefa manualmente, é possível automatizar a execução da tarefa, criando uma assinatura do IBM Cloud Object Storage que atende mudanças em um depósito do Object Storage. Quando você cria uma assinatura para um bucket, seu trabalho recebe um evento separado para cada alteração bem-sucedida nesse bucket.

1. Antes de criar uma assinatura do Object Storage, deve-se designar a função Notifications Manager para o Code Engine. Como um Gerenciador de notificações, o Code Engine pode visualizar, modificar e excluir notificações para um depósito do Object Storage. Siga as instruções aqui para atribuir a função de Gerenciador de Notificações ao seu projeto do Code Engine.
2. Execute o comando abaixo para conectar seu backend-job ao produtor de eventos do IBM Cloud Object Storage. Verifique e atualize o bucket name antes de executar o comando

   ibmcloud code-engine subscription cos create --name backend-job-cos-event --destination-type job --destination backend-job --bucket $COS_BUCKETNAME --prefix files --event-type write
   

3. Agora, basta fazer upload de novos arquivos e pressionar o botão atualizar para ver os resultados. Ao avançar, não é necessário reenviar a execução da tarefa, já que ela é cuidada pela assinatura.