Partilhar via

Implantar aplicativos no Azure Red Hat OpenShift usando o OpenShift Serverless

  • Artigo

Neste artigo, você implantará um aplicativo em um cluster do Azure Red Hat OpenShift com o OpenShift Serverless. O OpenShift Serverless ajuda os desenvolvedores a implantar e executar aplicativos que serão dimensionados ou dimensionados para zero sob demanda. Isso elimina o consumo de recursos quando eles não estão em uso.

O código do aplicativo pode ser empacotado em um contêiner junto com os tempos de execução apropriados. A funcionalidade sem servidor iniciará os contêineres de aplicativos quando eles forem acionados por um evento. Pode acionar aplicações através de vários eventos: a partir das suas próprias aplicações, de vários fornecedores de serviços na nuvem, sistemas de software como serviço (SaaS) e outros serviços.

Você pode usar recursos internos da interface OpenShift para gerenciar todos os aspetos da implantação de contêineres sem servidor. Os desenvolvedores podem identificar visualmente quais eventos estão impulsionando o lançamento de aplicativos em contêineres. Há também várias maneiras de modificar parâmetros de evento. Os aplicativos OpenShift Serverless podem ser integrados com outros serviços OpenShift, como OpenShift Pipelines, Service Mesh e Monitoring. Isso fornece uma experiência completa de desenvolvimento e implantação de aplicativos sem servidor.

Antes de começar

Criar um cluster

Siga o tutorial para criar um cluster do Azure Red Hat OpenShift. Se você optar por instalar e usar a interface de linha de comando (CLI) localmente, este tutorial exigirá que você use a CLI do Azure versão 2.6.0 ou posterior. Execute az --version para encontrar a versão atual. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).

Ligar ao cluster

Para gerenciar um cluster do Azure Red Hat OpenShift, você precisa usar oc, o cliente de linha de comando OpenShift.

Nota

Recomendamos que você instale a linha de comando OpenShift no Azure Cloud Shell e que a use para todas as operações de linha de comando neste artigo. Abra seu shell a partir de shell.azure.com ou selecione o link:

Botão para iniciar o Azure Cloud Shell

Siga o tutorial para instalar sua CLI, recuperar suas credenciais de cluster e conectar-se ao cluster com o console da Web e a CLI OpenShift.

Depois de iniciar sessão, deverá ver uma mensagem a dizer que está a utilizar o default projeto.

Login successful.

You have access to 61 projects, the list has been suppressed. You can list all projects with 'oc projects'

Using project "default".

Instalar a interface de linha de comando Knative (kn)

Transfira a versão mais recente da interface de linha de comandos (CLI) apropriada para a sua máquina, a partir dehttps://github.com/knative/client/releases/

Se você executar comandos no Azure Cloud Shell, baixe a CLI Knative mais recente para Linux.

cd ~
wget https://github.com/knative/client/releases/download/v0.22.0/kn-linux-amd64

mkdir knative
chmod +x kn-linux-amd64
mv kn-linux-amd64 knative/kn
echo 'export PATH=$PATH:~/knative' >> ~/.bashrc && source ~/.bashrc

Abra o console da Web OpenShift

Localize a URL do console da Web do cluster executando o seguinte script:

 az aro show \
    --name <cluster name> \
    --resource-group <resource group> \
    --query "consoleProfile.url" -o tsv

Você deve obter um URL semelhante ao seguinte.

https://console-openshift-console.apps.wzy5hg7x.eastus.aroapp.io/

Abra um navegador da Web e abra o URL do console. Faça login usando kubeadmin credenciais.

Uma captura de tela que mostra a tela de logon do Azure Red Hat OpenShift

Instalar o operador OpenShift Serverless

Quando você estiver conectado ao console da Web OpenShift, confirme se você está na visualização Administrador . Abra o Operator Hub e selecione o operador OpenShift Serverless .

Uma captura de tela que mostra a posição do operador OpenShift Serverless.

Em seguida, abra a página de instalação do operador selecionando Instalar.

Uma captura de tela que mostra como selecionar Instalar para instalar o operador.

Escolha o canal de atualização apropriado para a versão de cluster do Azure Red Hat OpenShift e instale o operador no openshift-serverless namespace. Role para baixo e selecione Instalar.

Uma captura de tela que mostra a página de instalação do Operador.

Em poucos minutos, a página de status reflete que o operador está instalado e pronto para uso. Selecione o botão Exibir operador para continuar.

Uma captura de tela que mostra a página de status com o operador instalado e pronto para uso.

Instalar o Knative Serving

A opção de executar um contêiner de forma sem servidor no OpenShift Serverless é possível usando o Knative upstream. O Knative estende o Kubernetes para fornecer um conjunto de componentes que implantam, executam e gerenciam aplicativos modernos por meio de sua metodologia sem servidor.

Criar uma instância do Knative Serving

No canto superior esquerdo da janela, na lista Projeto , selecione knative-server. Em seguida, no painel APIs fornecidas, selecione Criar instância no cartão de serviço Knative .

Uma captura de tela que mostra onde selecionar para criar uma instância do Knative Service.

Na página Criar serviço nativo, mantenha todos os valores padrão. Role para baixo e selecione o botão Criar .

Uma captura de tela que mostra os valores padrão listados no formulário.

O OpenShift Serverless é instalado quando a coluna Status mostra Pronto. Agora você está pronto para criar um projeto OpenShift Serverless.

Uma captura de tela que mostra que o Knative Serving está pronto.

Criar um projeto sem servidor

Para criar um novo projeto chamado demoserverless, execute o seguinte comando:

oc new-project demoserverless

O resultado deve ser semelhante ao seguinte:

Now using project "demoserverless" on server "https://api.wzy5hg7x.eastus.aroapp.io:6443".

You can add applications to this project with the 'new-app' command. For example, build a new example application in Python with the following:

    oc new-app django-psql-example

Or use kubectl to deploy a simple Kubernetes application:

    kubectl create deployment hello-node --image=gcr.io/hello-minikube-zero-install/hello-node

Vamos mudar da vista Administrador para a vista Programador. Vá para a sua lista de projetos no menu à esquerda e selecione demoserverless. Agora você está na página Topologia do projeto.

Uma captura de tela que mostra a topologia do projeto Azure Red Hat OpenShift.

Implantar usando o console da Web

Na página Topologia, selecione Do Git. Na página Importar do Git, use https://github.com/sclorg/django-ex.git como URL do Git Repo. Um aplicativo Web de exemplo é implementado com a linguagem de programação Python.

Uma captura de tela que mostra o projeto Azure Red Hat OpenShift de dentro do Git.

Nota

O OpenShift deteta que este é um projeto Python e seleciona a imagem do construtor apropriada.

Role até Recursos e confirme se Knative Service está selecionado como o tipo de recurso a ser gerado. Isso criará um Knative Service, um tipo de implantação que permite o escalonamento sem servidor do OpenShift para zero quando ocioso.

Uma captura de tela que mostra como selecionar o Serviço Kunative.

Na parte inferior da página, selecione Criar. Isso cria recursos para gerenciar a compilação e a implantação do aplicativo. Em seguida, você será redirecionado para a visão geral da topologia do projeto.

A visão geral da topologia fornece uma representação visual do aplicativo que você implantou. Você pode ver a estrutura geral do aplicativo.

Aguarde a conclusão da compilação. Esta operação poderá demorar alguns minutos. Quando a compilação for concluída, uma marca de seleção verde aparecerá no canto inferior esquerdo do serviço.

Uma captura de tela que mostra uma marca de seleção que indica que a compilação foi concluída.

Veja a escala do seu aplicativo

Na parte superior da vista Topologia, na lista Opções de Visualização, selecione Contagem de Pods. Aguarde até que a contagem de Pods diminua para zero Pods. A redução pode levar alguns minutos.

Uma captura de tela que mostra a contagem de Pods quando ela foi dimensionada para zero.

No canto superior direito do painel Knative Service, selecione o ícone Abrir URL . O aplicativo é aberto em uma nova guia do navegador. Feche a guia e retorne à visualização Topologia. Lá você pode ver que seu aplicativo foi dimensionado para um Pod, para acomodar sua solicitação. Após alguns minutos, seu aplicativo é reduzido para zero Pods.

Uma captura de tela que mostra o aplicativo dimensionado para Pod.

Forçar uma nova revisão e definir a distribuição do tráfego

Os serviços Knative permitem o mapeamento de tráfego, o que significa que as revisões de um serviço podem ser mapeadas para uma parte alocada do tráfego. A cada atualização de configuração de serviço, uma nova revisão é criada. Em seguida, a rota de serviço aponta todo o tráfego para a última revisão pronta por padrão. Você pode alterar esse comportamento definindo qual revisão obtém partes do tráfego. O mapeamento de tráfego também oferece a opção de criar URLs exclusivas para revisões individuais.

Na topologia criada, selecione a revisão exibida dentro do seu serviço para exibir seus detalhes. Os emblemas sob o anel Pod e na parte superior do painel de detalhes devem ser (REV). No painel lateral, dentro da guia Recursos, role para baixo e selecione a configuração associada ao seu serviço.

Uma captura de tela que mostra o anel Pod.

Força uma atualização de configuração alternando para a guia YAML e rolando para baixo para editar o valor de timeoutSeconds. Altere o valor para 301. Selecione Guardar. Em um cenário do mundo real, as atualizações de configuração também podem ser acionadas atualizando a tag de imagem do contêiner.

Uma captura de tela que mostra como forçar uma nova revisão atualizando a configuração.

Voltando para a visualização Topologia , você verá que uma nova revisão foi implantada. Selecione o serviço que termina com o selo (KSVC) e selecione o botão Definir distribuição de tráfego. Agora você deve ser capaz de dividir o tráfego entre as revisões no serviço.

Uma captura de tela que mostra como definir a distribuição de tráfego.

A visualização Topologia agora mostrará como o tráfego é distribuído entre as revisões.

Uma captura de tela que mostra como revisar a distribuição de tráfego.

Usando a interface de linha de comando Knative (kn)

Nas etapas anteriores, você usou o console da Web OpenShift para criar e implantar um aplicativo no OpenShift Serverless. Como o OpenShift Serverless está executando o Knative por baixo, você também pode usar a interface de linha de comando Knative (kn) para criar serviços Kunative.

Nota

Se você ainda não instalou a kn CLI, siga as etapas na seção de pré-requisitos deste artigo. Certifique-se também de que iniciou sessão utilizando a interface ocde linha de comandos OpenShift.

Vamos usar uma imagem de contêiner que já está construída em quay.io/rhdevelopers/knative-tutorial-greeter.

Implementar um serviço

Para implantar o serviço, execute o seguinte comando:

kn service create greeter \
--image quay.io/rhdevelopers/knative-tutorial-greeter:quarkus \
--namespace demoserverless \
--revision-name greeter-v1

Você verá uma saída semelhante à seguinte.

Creating service 'greeter' in namespace 'demoserverless':

  0.044s The Route is still working to reflect the latest desired specification.
  0.083s ...
  0.114s Configuration "greeter" is waiting for a Revision to become ready.
 10.420s ...
 10.489s Ingress has not yet been reconciled.
 10.582s Waiting for load balancer to be ready
 10.763s Ready to serve.

Service 'greeter' created to latest revision 'greeter-v1' is available at URL:
http://greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io

Você pode recuperar uma lista de rotas no projeto executando:

kn route list

Você receberá de volta uma lista de rotas no namespace. Abra a URL em um navegador da Web para exibir o serviço implantado.

NAME      URL                                                            READY
greeter   http://greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io   True

Implantar uma nova versão do serviço

Implante uma nova versão do aplicativo executando o seguinte comando e passando a :latest marca de imagem e uma variável MESSAGE_PREFIXde ambiente :

kn service update greeter \
 --image quay.io/rhdevelopers/knative-tutorial-greeter:latest \
 --namespace demoserverless \
 --env MESSAGE_PREFIX=GreeterV2 \
 --revision-name greeter-v2

Você receberá de volta uma confirmação de que uma nova revisão greeter-v2 foi implantada.

Updating Service 'greeter' in namespace 'demoserverless':

  5.029s Traffic is not yet migrated to the latest revision.
  5.086s Ingress has not yet been reconciled.
  5.190s Waiting for load balancer to be ready
  5.332s Ready to serve.

Service 'greeter' updated to latest revision 'greeter-v2' is available at URL:
http://greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io

Para exibir uma lista de todas as revisões e suas distribuições de tráfego, execute o seguinte comando:

kn revision list

Você obterá uma lista semelhante à saída a seguir. Observe que, neste caso, a nova revisão recebe 100% do tráfego.

NAME            SERVICE   TRAFFIC   TAGS   GENERATION   AGE     CONDITIONS   READY   REASON
greeter-v2      greeter   100%             2            90s     3 OK / 4     True
greeter-v1      greeter                    1            5m32s   3 OK / 4     True

Implantações azuis/verdes e canárias

Quando uma nova revisão é implantada, por padrão, ela recebe 100% do tráfego. Digamos que você queira implementar uma estratégia de implantação azul/verde onde você possa reverter rapidamente para a versão mais antiga do aplicativo. Knative torna isso fácil.

Você pode atualizar o serviço para criar três tags de tráfego, atribuindo 100% do tráfego a elas.

  • atual: aponta para a versão atualmente implantada
  • anterior: aponta para a versão anterior
  • Mais recente: sempre aponta para a versão mais recente
kn service update greeter \
   --tag greeter-v2=current \
   --tag greeter-v1=prev \
   --tag @latest=latest

Você receberá uma confirmação semelhante à seguinte.

Updating Service 'greeter' in namespace 'demoserverless':

  0.037s Ingress has not yet been reconciled.
  0.121s Waiting for load balancer to be ready
  0.287s Ready to serve.

Service 'greeter' with latest revision 'greeter-v2' (unchanged) is available at URL:
http://greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io

Liste rotas usando o comando abaixo:

kn route describe greeter

Você receberá uma saída mostrando os URLs de cada uma das tags, juntamente com sua distribuição de tráfego.

Name:       greeter
Namespace:  demoserverless
Age:        10m
URL:        http://greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io
Service:    greeter

Traffic Targets:
  100%  @latest (greeter-v2) #latest
        URL:  http://latest-greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io
    0%  greeter-v1 #prev
        URL:  http://prev-greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io
    0%  greeter-v2 #current
        URL:  http://current-greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io

[..]

Digamos que você queira reverter rapidamente para a versão anterior, você pode atualizar a distribuição de tráfego para enviar 100% do tráfego para a tag anterior:

kn service update greeter --traffic current=0 --traffic prev=100

Liste as rotas e verifique novamente, usando o seguinte comando:

kn route describe greeter

Você verá a saída mostrando que 100% da distribuição de tráfego está indo para a versão anterior.

Name:       greeter
Namespace:  demoserverless
Age:        19m
URL:        http://greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io
Service:    greeter

Traffic Targets:
    0%  @latest (greeter-v2) #latest
        URL:  http://latest-greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io
  100%  greeter-v1 #prev
        URL:  http://prev-greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io
    0%  greeter-v2 #current
        URL:  http://current-greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io

[..]

Brinque com a distribuição de tráfego enquanto atualiza a rota principal no seu navegador (http://greeter-demoserverless.apps.wzy5hg7x.eastus.aroapp.io neste caso).

Clean up resources (Limpar recursos)

Quando terminar o aplicativo, você pode executar o seguinte comando para excluir o projeto:

oc delete project demoserverless

Você também pode excluir o cluster seguindo as instruções em Tutorial: Excluir um cluster do Azure Red Hat OpenShift 4.

Próximos passos

Neste guia, você aprendeu a:

  • Instale o operador OpenShift Serverless e o Knative Serving
  • Implantar um projeto sem servidor usando o console da Web
  • Implantar um projeto sem servidor usando a CLI Knative (kn)
  • Configurar implantações azuis/verdes e implantações canárias usando a CLI Knative (kn)

Saiba mais sobre como criar e implantar aplicativos sem servidor e orientados a eventos no Azure Red Hat OpenShift usando o OpenShift Serverless, siga a documentação Introdução ao OpenShift Serverless e a documentação Criando e gerenciando aplicativos sem servidor.