Guia de configuração para desenvolvedores Kubernetes

16 min de leitura
Patrocinado
Imagem de: Guia de configuração para desenvolvedores Kubernetes
Avatar do autor

Equipe TecMundo

@tec_mundo

Por Michael Brown

Publicado em 15 de maio de 2020

Este guia de configuração é principalmente destinado a desenvolvedores, escritores técnicos e testadores que estão ou estarão trabalhando e contribuindo com o projeto de código aberto Kubernetes. Por exemplo, é atribuído a pessoas que desejam fazer edições na documentação, correções de código e rascunhar novos recursos para o Kubernetes; que desenvolvem e utilizam diversos tipos de aplicações que usam a API Kubernetes, como ferramentas de criação de perfil, monitoramento e integração; e que desenvolvem serviços que se beneficiam especificamente do conjunto de recursos do Kubernetes.

A seção inicial explica o básico. As seções seguintes ajudam a configurar seu ambiente de desenvolvimento. Logo depois, você aprenderá a usar o GitHub e o Git com o projeto Kubernetes. Além disso, as seções finais fornecem conselhos sobre desenvolvimento, construção e teste, para que você possa contribuir com códigos úteis para o projeto Kubernetes.

Algumas perguntas básicas iniciais

Antes de começarmos, você pode ter algumas perguntas se for novo no Kubernetes.

O que é Kubernetes?

Kubernetes é um conjunto de aplicações escritas em go. Essas aplicações trabalham juntas para formar uma plataforma interativa para o gerenciamento de contêineres.

Onde está o código-fonte do Kubernetes?

GitHub

Kubernetes está disponível no GitHub.

O Kubernetes é um OSS?

Cloud Native Computing Foundation

Kubernetes é um software de código aberto e foi doado peao Google para a Cloud Native Computing Foundation (CNCF).

Onde o Kubernetes é executado?

Ubuntu

O Kubernetes é executado em muitos sistemas operacionais/distribuições. No entanto, este guia mostra as etapas de configuração para desenvolver e testar o Kubernetes no Ubuntu.

Pré-requisitos

Para acompanhar este guia de configuração, você precisará atender os seguintes pré-requisitos:

  • Ter uma conta GitHub;

  • Ter conhecimento básico de Git, bash e Linux.

Tempo estimado

O tempo estimado para as etapas neste guia de configuração depende inteiramente de você e onde já se encontra nesta sequência de etapas. Alguns desenvolvedores começarão a leitura e utilizarão os links skip-ahead (pular etapas, em tradução livre), ou talvez apenas usem este artigo como referência. Outros podem demorar meio dia, um dia inteiro, ou até mesmo alguns dias ou uma semana, por exemplo, caso estejam tendo muitos problemas ou sejam novos no desenvolvimento de software de fonte aberta, teste ou Linux.

Para resolver essas variações de tempo, forneço os pontos de skip-ahead. Quando certas coisas são muito demoradas, mesmo para especialistas, eu informo a vocês. Também forneço atalhos, que podem ser usados para você construir e testar apenas porções muito pequenas, tornando o processo mais rápido. A duração das operações pode depender do seu hardware. Por exemplo, algumas das ações de teste podem levar 10 minutos para um cluster rápido ou 20 horas em um notebook lento.

Seu ambiente de desenvolvimento

Comece criando o ambiente de desenvolvimento básico do Kubernetes:

Se você já configurou tudo de acordo com as suas preferências, fique à vontade para pular para GitHub e o projeto Kubernetes.

Configurando seu sistema operacional host

A primeira coisa que você precisa fazer é instalar o Ubuntu em algum lugar. O Ubuntu 16.04 ou 18.04 LTS Server ou Desktop será suficiente. Você também pode utilizar lançamentos não LTS mais recentes, isso é com você. Estou executando o 16.04 LTS Desktop em uma máquina virtual (VM) no meu iMac por meio do Virtual Box mais recente, o 18.04 LTS Desktop no meu laptop Mac por meio do Virtual Box e o 18.04 LTS Server em servidores bare metal que montei com as peças mais usadas.

Certamente, você pode usufruir de máquinas virtuais para o desenvolvimento do Kubernetes, e eu as uso, então não desanime se não possuir os recursos para desenvolver o seu próprio servidor.

Para configurar o Ubuntu no Virtual Box, conclua as seguintes etapas:

Considere as seguintes sugestões para configurações do Virtual Box:

  • Memória base 8g;

  • Disco rígido vdi 140g;

  • Área de transferência compartilhada – apenas bidirecional (se for desktop);

  • Memória de vídeo 128 MB (se for desktop);

  • Rede: NAT;

  • As adições de convidados devem ser instaladas (clique em VirtualBox VM > Devices > Insert Guest Additions CD Image se for desktop);

  • Regras de encaminhamento de porta (consulte o botão na seção Network avançada):

Regras

Configurando o Ubuntu

Se você estiver usando o Ubuntu Desktop, crie um terminal:

Terminal do Ubuntu

Em seguida, execute o atualizador de software:

Ubuntu

A captura de tela a seguir mostra a execução da atualização apt-get em um terminal:

Atualização apt-get em um terminal

Usando e configurando ssh

Se você instalou o desktop Ubuntu e deseja executar o ssh, conclua as seguintes etapas para começar a usar o ssh:

Use o seu PC ou cliente Mac para abrir o SSH no seu servidor Ubuntu ou desktop. Se você instalou a versão desktop do Ubuntu e deseja executar o ssh, execute os seguintes comandos:

$ sudo apt-get install openssh-server

$ sudo service ssh start or sudo /etc/init.d/ssh start

$ ssh -v localhost

Em seguida, faça o login em seu servidor ssh a partir de sua máquina cliente (com uma senha):

Log in no servidor shh

Para a versão do ssh opcional sem senha, conclua as seguintes etapas:

A execução de testes completos do Kubernetes costumava exigir a configuração do ssh sem senha (usando chaves em vez de senhas). Se você não quiser configurar o ssh sem senha, vá para Instalando o Go.

Primeiro, gere as chaves públicas e privadas do Ubuntu com o seguinte comando:

$ ssh-keygen -t rsa

Em seguida, utilize o local-padrão e digite uma senha ou apenas pressione ENTER:

$ ssh-copy-id mike@10.0.2.15

Em seu Mac, execute o seguinte comando no diretório ~/.ssh para gerar uma chave:

$ ssh-keygen -b 1024 -t rsa -f id_rsa -P ""

Copie e cole sua chave pública do Mac (por exemplo, cat~/.ssh/d_rsa.pub) em seu arquivo ubuntu guest /home/user/.ssh/authorized_keys.

Em seguida, configure seu guest do Ubuntu para o ssh sem senha:

$ sudo nano /etc/ssh/sshd\_config

Faça as seguintes edições para UN-comment/configure:

PubkeyAuthentication yes

AuthorizedKeyFile %h/.ssh/authorized\_keys

PasswordAuthentication no

PermitRootLogin without-password

Reinicie:

$ sudo service ssh restart or sudo /etc/init.d/ssh restart

Em seguida, faça o teste:

$ ssh mike@ubuntu (ubuntu = hostname) or 127.0.0.1 or 10.0.2.15 ...

Certifique-se de que está funcionando e saia.

Como você irá logar como root sem senha, poderá pegar um atalho e copiar as chaves pública e privada do usuário e as chaves autorizadas para /root/.ssh, por exemplo:

$ sudo cp ~/.ssh/authorized_keys /root/.ssh/authorized_keys (you may have to mkdir /root/.ssh)

$ sudo cp ~/.ssh/id_rsa /root/.ssh/id_rsa

$ sudo cp ~/.ssh/id_rsa.pub /root/.ssh/id_rsa.pub

Agora você deve ser capaz de executar o ssh, root ou usuário, para seu guest do Ubuntu, sem uma senha, da sua conta de usuário em seu terminal Mac:

Terminal 1:

ssh -p 2222 root@127.0.0.1

Terminal 2:

ssh -p 2222 mike@127.0.0.1

Você também deve ser capaz de excutar o ssh de suas contas de usuário ou root em seu host Ubuntu para suas contas de usuário e root em seu host Ubuntu:

$ ssh root@10.0.2.15

$ sudo ssh root@10.0.2.15

Instalando o Go

No momento da instalação, certifique-se de instalar a versão mais recente do Go compatível com o Kubernetes (ou a mais próxima possível).

Escolha a versão desejada em https://golang.org/dl/ e, em seguida, faça o download em seu host local:

  $ curl -O https://storage.googleapis.com/golang/go1.13.9.linux-amd64.tar.gz

Conclua as seguintes etapas de instalação:

$ tar -xvf go1.13.9.linux-amd64.tar.gz

$ sudo mv go /usr/local

$ rm go1.13.9.linux-amd64.tar.gz

Configure variáveis de ambiente para usuários aplicáveis, por exemplo, o usuário atualmente conectado (~):

$ sudo nano ~/.profile

E

$ sudo nano /root/.profile

Agora você adiciona a instrução de caminho de exportação a esses arquivos acrescentando esta linha:

$ export PATH=$PATH:/usr/local/go/bin:/home/mike/go/bin

Nota: /usr/local/go/ bin é para executar os binários go que vêm com o software, e /home/username/go/bin é para executar qualquer aplicação go que você desenvolveu com ele.

Teste a configuração:

$ go version

go version go1.13.9 linux/amd64

Para executar como sudo com as edições de seu perfil de usuário, execute o seguinte comando:

$ sudo su --

# source /home/mike/.profile

Embora seja mais arriscado, você pode realizar o login como root e alterar seu sudo secure_path por meio de visudo para adicionar caminhos para o go:

# visudo

Edite o secure_path padrão do sudo:

Defaults

secure\_path=\"/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin:/usr/local/go/bin:/home/mike/go/bin\"

Teste sua configuração de sudo:

$ sudo go version

go version go1.13.9 linux/amd64

Instalando o Docker e o containerd

Para obter mais informações, consulte Instalar o Docker Engine no Ubuntu.

Para instalar o Docker, primeiro você atualiza seus pacotes:

$ sudo apt-get update

Em seguida, remova todas as versões anteriores:

$ sudo apt-get remove docker docker-engine docker.io containerd runc

Instale o suporte de transporte https:

$ sudo apt-get install \

apt-transport-https \

ca-certificates \

curl \

gnupg-agent \

software-properties-common

Adicione a chave GPG do Docker:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Adicione as versões estáveis do Docker como um repositório apt:

$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Instale as versões estáveis mais recentes do Docker e do containerd:

$ sudo apt-get update

$ sudo apt-get install docker-ce docker-ce-cli containerd.io

Para escolher uma versão específica do Docker, execute o seguinte comando:

$ sudo apt-get install docker-ce= docker-ce-cli= containerd.io

Teste a instalação do Docker:

$ sudo docker run hello-world

Adicione-se ao grupo Docker que é executado como sudo para que possa executar o Docker sem digitar sudo:

$ sudo usermod -aG docker mike

Reinicie seu host Ubuntu:

$ sudo shutdown -r

Faça o login novamente em seu host com ssh após a reinicialização do host e teste o docker novamente, sem sudo desta vez:

$ docker run hello-world

Instalando build tools

Execute o seguinte comando:

$ sudo apt-get install build-essential

Instalando jq

Execute o seguinte comando para instalar o jq (um processador JSON):

$ sudo apt-get install jq

Instalando o python-pip e o pyyaml

Execute os seguintes comandos para instalar o python-pip e o pyyaml:

$ sudo apt-get install python-pip

$ sudo pip install pyyaml

GitHub e o projeto Kubernetes

Primeiramente, vamos dar uma olhada em bifurcações e, em seguida, como cloná-las. Logo após, há várias considerações para perfis e configuração do cliente. Por fim, você aprenderá sobre o fluxo de trabalho Git para o projeto Kubernetes.

Bifurcação

Crie suas bifurcações de desenvolvimento no GitHub para:

Bifurcações

Clonando suas bifurcações

Normalmente, ao clonar um repositório de origem github.com, você usa o caminho $GOPATH/src/github.com ou o caminho ~/go/src/github.com/projectname (representando o caminho para a origem no GitHub). O motivo é a conveniência ao utilizar os comandos go get type para obter pacotes hospedados no GitHub.

No entanto, por motivos de legado, os pacotes do Kubernetes são nomeados k8s.io/kubernetes, não github.com/kubernetes/kubernetes, como você pode esperar. Portanto, para fazer com que todas as ferramentas de desenvolvimento funcionem corretamente, para poder encontrar o código do pacote no disco, é necessário que você coloque o clone em um diretório k8s.io.

Crie as árvores de origem k8s.io/kubernetes a partir de suas bifurcações em name/kubernetes utilizando as seguintes etapas:

mike@mike-VirtualBox:~/go/src$ mkdir k8s.io

mike@mike-VirtualBox:~/go/src$ cd k8s.io

$ git clone https://github.com/mikebrow/kubernetes.git

$ git clone https://github.com/mikebrow/website.git

$ git clone https://github.com/mikebrow/test-infra.git

Resultado: os arquivos de origem são copiados (clonados) de suas bifurcações para os diretórios go/src/k8s.io/kubernetes e k8s.io/website. O Git cria um branch master em seu disco rígido local para as bifurcações do git hub.

Verifique o status do seu branch:

$ cd kubernetes

$ git status

On branch master

Your branch is up-to-date with 'origin/master`.

nothing to commit, working directory clean

Recomendações de perfil do GitHub

Considere as seguintes recomendações de perfil do GitHub:

  • Adicione um e-mail ao seu perfil público;

  • Ative a autenticação de dois fatores.

Recomendações de configuração do cliente Git

Considere as seguintes recomendações de configuração do cliente.

Defina as entradas user. * como global, local ou ambos:

$ git config --local user.name "full name here"

$ git config --local user.email "email address here"

Ou

$ git config --global user.name "full name here"

$ git config --global user.email "email address here"

Torne o push mais fácil:

$ git config --global push.default simple

Execute o seguinte comando para não ter que lembrar de suas credenciais do GitHub todas as vezes:

$ git config credential.helper store

Diga ao git para rastrear alterações no branch clonado em seu disco rígido em relação a kubernetes/kubernetes:

$ git remote add upstream https://github.com/kubernetes/kubernetes.git

A execução de git config -l deve ser semelhante a:

user.name=Mike Brown

user.email=brownwm@us.ibm.com

push.default=simple

core.repositoryformatversion=0

core.filemode=true

core.bare=false

core.logallrefupdates=true

remote.origin.url=https://github.com/mikebrow/kubernetes.git

remote.origin.fetch=+refs/heads/*:refs/remotes/origin/*

branch.master.remote=origin

branch.master.merge=refs/heads/master

remote.upstream.url=https://github.com/kubernetes/kubernetes.git

remote.upstream.fetch=+refs/heads/*:refs/remotes/upstream/*

credential.helper=store

O fluxo de trabalho Git para o projeto de código aberto Kubernetes

O diagrama a seguir mostra um fluxo de trabalho típico do Git para encontrar e corrigir um problema com um produto de código aberto no GitHub. Embora esse fluxo tenha sido elaborado para o Docker, ele também funciona para o Kubernetes.

Workflow (fluxo de trabalho) do Git

Encontre algo para trabalhar aqui, nos problemas do Kubernetes: https://github.com/kubernetes/kubernetes/issues

Problemas do Kubernetes

Faça um comentário sobre o problema que você encontrou.

Se tiver dúvidas, não seja tímido.

Se quiser trabalhar nisso, diga. Por exemplo, adicione uma frase que indique que você está chamando #dibs para mostrar que está trabalhando neste problema.

Se você não tem certeza se pode resolver o problema sozinho, pelo menos anuncie que está investigando com #investigating. Assim, não estará atribuído à tarefa, mas isso permite que outros saibam que você pode estar interessado mais tarde.

Desenvolvimento do Kubernetes (instalando etcd)

Antes de construir o Kubernetes, você precisa instalar o etcd. O seguinte script está incluído no Kubernetes para instalar o etcd:

$ hack/install-etcd.sh

Adicione o caminho exibido ao etcd aos seus perfis de usuário. Por exemplo, adicione /home/mike/go/src/k8s.io/kubernetes/third_party/etcd aos seus caminhos com o seguinte comando:

$ sudo nano ~/.profile

$ sudo nano /root/.profile

E, se quiser, adicione-o ao seu secure\_path para sudo:

$ sudo su -

# visudo

Agora, o caminho seguro deve ser exibido assim:

Defaults

secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin:/usr/local/go/bin:/home/mike/go/bin:/home/mike/go/src/k8s.io/kubernetes/third_party/etcd"

Reinicie seu host:

$ sudo shutdown -r

Faça login novamente em seu host com ssh após a reinicialização do host e teste o etcd:

$ etcd --version

$ sudo etcd --version

Desenvolvendo o Kubernetes com make

Use o alvo de ajuda para mostrar as opções de make:

$ make help

Algumas isenções de responsabilidade e avisos: na primeira vez que você cria, verifica e testa, o Kubernetes leva muito tempo por estar compilando e baixando um número significativo de imagens de grandes contêineres. Alguns downloads podem falhar, causando erros inesperados de compilação e teste na primeira e possivelmente na segunda vez em que você tentar executá-los. Além disso, como você estará desenvolvendo com base em erros "principais", estes podem ser esperados em algumas ou muitas partes do teste, e alguns erros ocorrem apenas após longos tempos limite, portanto, é necessário ter paciência. Mesmo que tudo já tenha sido baixado e não haja erros, espere que as etapas de desenvolvimento, verificação e teste levem um tempo significativo.

Se você quiser desenvolver tudo para executar o Kubernetes localmente, use o destino all:

$ sudo make all

Se você deseja desenvolver apenas um dos pacotes/executáveis, use make WHAT = cmd/package\_name. Por exemplo, para desenvolver o servidor kublet, execute o seguinte comando:

$ sudo make WHAT=cmd/kublet

Dependendo do que você alterou, os pacotes cliente/servidor nem sempre podem ser compilados. Se você deseja forçar a sincronização de ambos (limpar/remover binários de compilação), use clean:

$ sudo make clean

Para gerar uma versão, execute o seguinte comando:

$ sudo make release

Para gerar uma versão sem executar testes, execute o seguinte comando:

$ sudo make release-skip-tests

Testando Kubernetes (unidade e integração)

Antes de submeter alterações ao seu branch de desenvolvimento local, é recomendado que você execute testes de verificação, unidade e integração. Dependendo do tipo de alteração, você também pode querer executar depósitos de teste de ponta a ponta.

Crie testes de verificação (por exemplo, verificação de pré-envio) a serem feitos antes de enviar um PR para kubernetes/kubernetes:

$ sudo make verify

Execute o seguinte comando para testes de unidade:

$ sudo make test

Execute o seguinte comando apenas para os testes pkg/api/pod:

$ sudo make test WHAT=./pkg/api/pod

Execute apenas os testes de kubelet no modo detalhado:

$ sudo make test WHAT=./pkg/kubelet GOFLAGS=-v

Execute os testes de pod e kubelet no modo detalhado:

$ sudo make test WHAT="./pkg/api/pod ./pkg/kubelet" GOFLAGS=-v

Execute o seguinte comando para testes de integração:

$ sudo make test-integration

Execute o seguinte comando para testes de integração do kubelet:

$ sudo make test-integration WHAT=./test/integration/kubelet

Execute os testes de integração do pod em modo detalhado:

$ sudo make test-integration WHAT=./test/integration/pods GOFLAGS="-v"

Testes ponta a ponta do Kubernetes

As seções a seguir mostram como executar testes Kubernetes ponta a ponta, ou e2e (end-to-end, em inglês).

1. Instale o kubetest

Execute os seguintes comandos para instalar o kubetest:

$ cd ../test-infra

$ sudo GO111MODULE=on go install ./kubetest

$ cd ../kubernetes

2. Crie um cluster local

A execução dos testes do Kubernetes e2e requer o uso de um cluster. Os testes e2e podem ser executados em qualquer cluster compatível com Kubernetes. Este guia mostra como criar um cluster de nó único em execução em seu ambiente Linux. Se você seguiu as instruções anteriores, este cluster é executado em sua conta de guest do Ubuntu em sua VM ou host Ubuntu em bare metal. Você utiliza dois terminais.

Uma observação sobre o teste de ponta a ponta: com as opções de teste e2e padrão, quando a versão do cliente e do servidor estão fora de sincronia, os testes e2e não são executados. Agora você pode executar o e2e com as versões fora de inclinação, definindo o check_version_skew = false.

No terminal 1, crie o Kubernetes e inicie seu cluster local:

$ sudo make clean

$ sudo make

$ sudo PATH=$PATH hack/local-up-cluster.sh

No terminal 2, configure kubectl para interagir com seu cluster local:

$ export KUBECONFIG=/var/run/kubernetes/admin.kubeconfig

Verifique o status do seu cluster local de nó único:

$ cluster/kubectl.sh get nodes

NAME        STATUS    AGE

127.0.0.1   Ready     3h

3. Execute os testes e2e

No terminal 2, execute o bloco de teste e2e secrets:

$ sudo kubetest --provider=local --test --test_args="--minStartupPods=1 --ginkgo.focus=Secrets"

Nota: O minStartupPods é definido como 1 para refletir que você tem apenas um nó em seu cluster local.

Agora execute todos os testes e2e (isso leva bastante tempo para ser concluído):

$ sudo kubetest --provider=local --test --test_args="--minStartupPods=1"

Quando terminar de usar seu cluster Kubernetes, você pode desativá-lo rapidamente com ctrl-C no terminal 1.

Para obter mais informações sobre o teste ponta a ponta, consulte e2e-tests.

Testes de nó ponta a ponta (e2e) do Kubernetes

As seções a seguir mostram como você executa testes de nós completos do Kubernetes, também conhecidos como testes de nó e2e.

1. Instale o ginkgo

Execute os seguintes comandos:

$ sudo go get -u github.com/onsi/ginkgo/ginkgo

$ sudo go get -u github.com/onsi/gomega/...

2. Inicie um cluster

No terminal 1, inicie seu cluster de nó único local:

$ sudo PATH=$PATH hack/local-up-cluster.sh

No terminal 2, configure kubectl para interagir com seu cluster local:

$ export KUBECONFIG=/var/run/kubernetes/admin.kubeconfig

3. Execute os testes do nó e2e

Execute os testes do nó Sysctls e2e localmente:

$ sudo make test-e2e-node PARALLELISM=1 FOCUS=Sysctls

Execute todos os testes do nó e2e (esta etapa leva bastante tempo para ser concluída):

$ sudo make test-e2e-node PARALLELISM=1

Mais informações sobre o teste de nó ponta a ponta estão disponíveis no documento e2e-node-tests.

Desenvolvendo arquivos gerados

Depois de editar os arquivos de origem que são utilizados na geração de outros arquivos de origem na árvore kubernetes/kubernetes, você deve atualizar os arquivos gerados antes de fazer um git commit. Execute o seguinte comando:

$ sudo make update

Running update-generated-protobuf

Running update-codegen

Running update-generated-runtime

Running update-generated-device-plugin

...

O site de documentação do Kubernetes

Se você quiser contribuir com a documentação do Kubernetes, siga estas instruções.

Outras coisas para fazer

Você ainda não está no momento de parar. Aqui estão mais algumas tarefas que você deve realizar:

  • Execute gofmt -s -w file.go em cada arquivo alterado antes de confirmar suas alterações;

  • Execute o golint em cada arquivo alterado antes de confirmar suas alterações (a equipe do Kubernetes não usa lint atualmente, mas não faz mal);

  • Lembre-se de atualizar a documentação ao criar ou modificar recursos;

  • Lembre-se de adicionar casos de teste para cobrir suas alterações;

  • Os commits que corrigem ou fecham um problema devem fazer referência a eles na mensagem de commit: Closes #XXXX ou Fixes #XXXX;

  • Após cada confirmação, execute o conjunto de testes e certifique-se de que ele seja aprovado;

  • Sincronize e rebase frequentemente enquanto você codifica para acompanhar o mestre.

Resumo

Espero que este guia tenha ajudado você a começar sua jornada para o desenvolvimento do Kubernetes. Revise e siga as diretrizes da comunidade do Kubernetes para se tornar um contribuidor, membro, revisor, aprovador (também conhecido como "committer" e "mantenedor") e/ou proprietário de um subprojeto.

Você pode entrar em contato comigo em brownwm@us.ibm.com e https://twitter.com/mikebrow.

...

Quer ler mais conteúdo especializado de programação? Conheça o IBM Blue Profile e tenha acesso a matérias exclusivas, novas jornadas de conhecimento e testes personalizados. Confira agora mesmo, consiga as badges e dê um upgrade na sua carreira!

…..

Quer dar o próximo grande passo na sua jornada profissional? Participe do Cloud Training, um curso online e gratuito que vai te preparar para o exame da certificação IBM Cloud Foundations. Inscreva-se já!

Guia de configuração para desenvolvedores Kubernetes