Introdução ao KubeVela: uma maneira melhor de enviar aplicativos

O Kubernetes já venceu a batalha de orquestração de contêineres. Mas a guerra que os desenvolvedores ainda precisam superar com o Kubernetes é sua complexidade. É aqui que o KubeVela entra em jogo.

O KubeVela torna a implantação de aplicativos no Kubernetes muito mais fácil. Em vez de saber sobre serviço, implantação, pods e escalonamento de pod horizontal, você pode especificar uma configuração muito mais leve. Vamos nos aprofundar em como.

O que é KubeVela?

KubeVela é uma ferramenta de código aberto que abstrai os complicados artefatos do Kubernetes dos desenvolvedores-e, até certo ponto, construtores de plataforma-para criar um experiência de implantação mais simples.

Como engenheiro de software, os artefatos do Kubernetes podem ser opressores no início. É aqui que o KubeVela atua como uma ponte muito necessária que permite aos desenvolvedores se preocupar menos com os artefatos subjacentes. KubeVela ajuda os desenvolvedores e construtores de plataforma, fornecendo uma boa estrutura que fornece uma plataforma amigável, mas altamente extensível.

Seu slogan é “Torne os aplicativos de remessa mais agradáveis” e acho que ele faz jus a esse slogan. KubeVela é baseado na especificação Open Application Model (OAM) , que coloca o foco diretamente no aplicativo em vez do contêiner ou orquestrador.

Onde o KubeVela se encaixa no ecossistema Kubernetes?

Artefatos do Kubernetes, como serviço, implantação, escalonador de pod horizontal, etc. parecem assustadores à primeira vista, mas depois de algum tempo, a pessoa se acostuma com eles. Existem muitas ferramentas excelentes para implantar aplicativos no Kubernetes e abstrair os detalhes internos dos artefatos do Kubernetes.

Algumas dessas ferramentas úteis incluem Helm , Skaffold e Rascunho , para citar alguns. Podemos encontrar uma boa comparação desses tipos de ferramentas em esta postagem útil .

Ainda assim, nenhuma dessas ferramentas é voltada para desenvolvedores e operadores de plataforma da mesma forma que o KubeVela. KubeVela oferece uma maneira amigável e simples de definir aplicativos que podem ser facilmente implantados e atualizados em qualquer cluster do Kubernetes.

Implante um aplicativo Node.js express simples com KubeVela

Nesta demonstração, implantaremos um aplicativo Node.js Express simples que já foi encaixado no dock , e a imagem Docker está disponível em Docker Hub .

Pré-requisitos

Antes de começar e definir o arquivo do aplicativo KubeVela, vamos primeiro esclarecer alguns pré-requisitos:

• Você deve saber sobre o Kubernetes e como ele geralmente funciona
• Você deve ter kubectl e Helm instalado e em execução em seu ambiente de teste
• Você está ciente de como o registro de contêiner funciona e como enviar e receber imagens de contêiner

Executaremos esta demonstração no cluster tipo do Kubernetes. De acordo com seu leia-me, tipo é “uma ferramenta para executar clusters Kubernetes locais usando‘ nós ’de contêiner do Docker.

Vamos configurar nosso cluster Kubernetes local usando kind. Descreveremos as etapas abaixo.

Configure um cluster Kubernetes local com o tipo

Dependendo do seu sistema operacional, você pode ter uma maneira diferente de instalar o tipo CLI. Estou usando um Mac, então executei o seguinte comando:

 tipo de instalação preparada

Você poderá encontrar o comando específico do sistema operacional para instalar o tipo em sua página de instalação .

Antes de prosseguir, certifique-se de que as portas 80 e 443 estejam abertas em sua máquina local. Isso significa que você precisará interromper quaisquer servidores como Apache ou NGINX ocupando a porta 80. Além disso, verifique se não há nenhum outro serviço ocupando a porta 80 localmente como um proxy NGINX, que pode estar sendo executado como um Contêiner do Docker também.

Para criar nosso cluster Kubernetes local com kind, executaremos o seguinte comando:

 cat <
 Isso cria um tipo de cluster Kubernetes com portas 80 e 443 do mapeamento do contêiner para sua máquina local. 
 Deve demorar alguns minutos e voltar com um resultado como o abaixo: 
  
 Para a próxima etapa, configuraremos nosso  kubectl  para usar o cluster Kubernetes que acabamos de criar executando: 
 kubectl cluster-info--context kind-kind

 A seguir, instalaremos o Ingress em nosso cluster Kubernetes com kind executando: 
 kubectl apply-f https://raw.githubusercontent.com/kubernetes/ingress-nginx/master/deploy/static/provider/kind/deploy.yaml

 O comando acima nos mostrará algo como abaixo: 
  
 Para verificar rapidamente se temos algum pod em execução no cluster Kubernetes recém-criado, podemos executar: 
 kubectl get po-A

 Ele nos mostrará pods em execução em todos os namespaces como abaixo: 

  
 Viva, nosso cluster Kubernetes está instalado e funcionando. A próxima etapa é instalar o KubeVela-vamos lá. 
 Instale KubeVela no cluster K8s local 
 Agora que temos nosso tipo de cluster Kubernetes em execução localmente dentro de um contêiner do Docker (tente  docker ps  para verificar), prosseguiremos com a instalação do KubeVela. Para instalar o KubeVela com Helm, execute o seguinte comando: 
 helm repo adicionar kubevela https://kubevelacharts.oss-cn-hangzhou.aliyuncs.com/core && helm repo update

 Ele nos mostrará a seguinte saída: 
  
 Para tornar as coisas mais fáceis, combinamos dois comandos. O primeiro obtém o gráfico do Helm para KubeVela e o segundo atualiza o repositório de ajuda. 
 Para a próxima etapa, executaremos novamente dois comandos juntos: 
 kubectl criar namespace sistema-vela && helm install-n sistema-vela kubevela kubevela/vela-core--set installCertManager=true

 Esses dois comandos nos mostram uma saída como abaixo: 
  
 O primeiro comando aqui cria o namespace  vela-system  em nosso cluster Kubernetes. O segundo comando instala o gráfico KubeVela Helm no namespace  vela-system  criado no comando anterior com cert-manager. 

 De acordo com a  documentação de instalação do KubeVela , o KubeVela depende do cert-manager para criar certificados para webhooks. 
 Neste ponto, se executarmos  kubectl get po-n vela-system  para verificar se o KubeVela está funcionando corretamente, ele nos mostrará um pod cujo nome começa com  kubevela-veal-core- em execução. Agora sabemos que o KubeVela está instalado em nosso cluster Kubernetes e em execução com êxito. 
 Na próxima etapa, instalaremos a  vela  CLI. 
 Instale o KubeVela CLI 
 Para instalar a vela CLI em um Mac, executei o seguinte comando: 
 curl-fsSl https://kubevela.io/install.sh | bash

 Dependendo do seu sistema operacional, você pode encontrar o comando relevante para obter o CLI nesta  página . 
 Para verificar se sua  vela  CLI está instalada corretamente, execute a  vela version , e você deverá ver uma saída como abaixo: 
  
 Usaremos a CLI  vela  para criar um arquivo  vela.yaml  que define como o aplicativo deve ser implantado no Kubernetes. É hora de brincar com a CLI da  vela  agora. 
 ‘Velaize’ e implante nosso aplicativo Node.js 
 Consequentemente, iremos “Velaizar” nosso aplicativo de demonstração expresso Node.js existente que já foi encaixado. Para simplificar as coisas, enviei o  aplicativo  para  Docker Hub . Como você já deve estar ciente, para implantar nosso aplicativo, o contêiner deve ser enviado para um registro de contêiner. Usaremos o Docker Hub como nosso registro de contêiner para esta demonstração. 
 Para experimentar o aplicativo de demonstração em seu cluster Kubernetes, você pode ir para uma pasta vazia e executar: 
 Vela init

 Ele fará algumas perguntas, como o nome do aplicativo, o nome do serviço, o tipo de carga de trabalho e a imagem Docker do serviço. Preencha-o como abaixo; o principal aqui é a imagem do serviço, que aponta para  geshan/nodejs-docker-express , hospedado no Docker Hub: 
  
 Nosso aplicativo Node.js será executado na porta 3000 e, por padrão, a tag mais recente para a imagem Docker será puxada e implantada no Kubernetes pelo KubeVela. 
 Execute  vela status testapp  para visualizar o status do aplicativo da seguinte maneira: 
  
 Outra maneira de verificar isso rapidamente é executando  kubectl get po , que deve mostrar um pod em execução. 
 O comando  vela init  criou um arquivo  vela.yaml  com o seguinte conteúdo: 
 createTime:"2021-02-09T13: 51: 25.723862 + 11: 00"
nome: testapp
Serviços: node-express: imagem: geshan/nodejs-docker-express porta: 3000 tipo: webservice
updateTime:"2021-02-09T13: 51: 25.723863 + 11: 00"

 Teste o aplicativo Node.js 
 Para testar o aplicativo Node.js Express em execução no cluster K8s local implantado com KubeVela, execute o seguinte comando: 
 aplicativo de teste para a porta da vela

 Ele mostrará uma saída como abaixo: 
  
 Agora, podemos clicar em   https://127.0.0.1:3000   em o navegador para ver nosso aplicativo em execução no cluster Kubernetes no contêiner da seguinte maneira: 
  
 Além disso, quando as alterações e atualizações da imagem do Docker são enviadas ao registro da imagem do Docker, podemos executar  vela up  para reimplantar o aplicativo. 
 Implante uma mudança com KubeVela 
 Para fins de demonstração, alterarei a mensagem de “Bem-vindo ao Express com Docker” para “Bem-vindo ao Express com Docker e KubeVela” e  push  como uma nova tag do Docker chamada  kubevela . Por padrão, até agora, ele estava usando a tag  mais recente . 
 Então, vamos mudar a tag no arquivo  vela.yaml , como abaixo: 
 createTime:"2021-02-09T13: 51: 25.723862 + 11: 00"
nome: testapp
Serviços: node-express: imagem: geshan/nodejs-docker-express: kubevela porta: 3000 tipo: webservice
updateTime:"2021-02-09T13: 51: 25.723863 + 11: 00"

 A mudança é adicionar a tag à imagem do Docker como  image: geshan/nodejs-docker-express: kubevela . Se a tag estiver disponível, podemos fazer: 
 vela para cima
vela status testapp #confirme se o aplicativo está ativo e íntegro
vela port-forward testapp

 Então, podemos ver as novas mudanças no navegador em:   http://127.0.0.1:3000   da seguinte maneira: 
  
 Aí está! Executamos um pequeno aplicativo Node.js Express que havia sido previamente encaixado em um cluster local Kubernetes (tipo) com KubeVela. Acho que foi muito mais fácil do que brincar com  serviço ,  implantação  e outros artefatos do Kubernetes. 
 O cluster local do Kubernetes deve ser tratado como seu playground para a prova de conceito. Podemos perceber a facilidade e flexibilidade que o KubeVela adiciona quando queremos implantar nossos aplicativos em contêineres em clusters Kubernetes de nível de produção. 
 Como esta é uma postagem de introdução, decidi não me aprofundar no  roteamento  e  dimensionamento automático  partes. Existem alguns  comandos alternativos  para adicionar esses recursos também. Eu deixaria que você explorasse esses poderes de KubeVela. 
 Conclusão 
 Vimos como implantar um aplicativo Node.js Express no Kubernetes usando KubeVela. O KubeVela torna mais fácil e muito mais amigável implantar qualquer aplicativo em contêiner no Kubernetes. Eu recomendaria experimentar o KubeVela se você e sua equipe estiverem se aventurando no cenário do Kubernetes por sua facilidade de uso e arquitetura flexível. 
 A postagem  Introdução ao KubeVela: uma maneira melhor de enviar aplicativos  apareceu primeiro no  LogRocket Blog . 
 Source link