Guia de configuração para desenvolvedores Kubernetes

Este guia de configuração é indicado principalmente para desenvolvedores, escritores técnicos e testadores que estejam trabalhando e contribuindo para o projeto de software livre Kubernetes ou pretendam fazer isso. Por exemplo, ele é direcionado a pessoas que desejam fazer edições na documentação, corrigir códigos e criar novos recursos para o Kubernetes, àqueles que desenvolvem e usam vários tipos de aplicativos que usam a API do Kubernetes, como ferramentas de criação de perfil, de monitoramento e de integração, e àqueles que desenvolvem serviços que aproveitam especificamente o conjunto de recursos do Kubernetes.

A seção inicial explica os conceitos básicos. As próximas seções ajudam a configurar o ambiente de desenvolvimento. Em seguida, você aprende a usar o GitHub e o Git com o projeto Kubernetes. As seções finais fornecem dicas sobre desenvolvimento e teste, para que seja possível contribuir com um código útil para o Kubernetes.

Algumas questões básicas iniciais

Antes de começar, se você é iniciante no Kubernetes, talvez tenha algumas dúvidas.

O que é o Kubernetes?

O Kubernetes é um conjunto de aplicativos escritos em Go. Esses aplicativos trabalham juntos para formar uma plataforma interativa para gerenciar contêineres.

Onde fica o código-fonte do Kubernetes?

Logo GitHub

O Kubernetes está disponível no GitHub.

O Kubernetes é um software livre?

Logo Cloud Native Computing Foundation

O Kubernetes é um software livre e foi doado pela Google para a Cloud Native Computing Foundation (CNCF).

Onde o Kubernetes é executado?

Logo Ubuntu

O Kubernetes é executado em diversos sistemas operacionais e 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, os seguintes pré-requisitos são necessários:

  • Uma conta do GitHub
  • Conhecimento básico de Git, bash e Linux

Tempo estimado

O tempo estimado para as etapas deste guia de configuração depende exclusivamente de você e de onde você já está nesta sequência de etapas. Alguns desenvolvedores começarão o processo e usarão os links para avançar, podendo usar este artigo somente como uma referência. Outros poderão demorar metade de um dia, um dia inteiro ou até mesmo alguns dias ou semanas, por exemplo, se você tiver muitos problemas ou for iniciante no desenvolvimento de software livre, nos processos de teste ou no Linux.

Para resolver essas variações de tempo, indicarei os pontos de avanço. Informarei quando alguma etapa for muito demorada, mesmo para especialistas. Também fornecerei atalhos que poderão ser usados para desenvolver e testar somente partes muito pequenas, para acelerar o processo. A duração das operações pode depender do seu hardware. Por exemplo, algumas das operações de teste podem demorar 10 minutos em um cluster rápido e 20 horas em um laptop lento.

Seu ambiente de desenvolvimento

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

  • Um terminal Linux e/ou um ssh. (Consulte “Configurando o sistema operacional host”, “Configurando o Ubuntu e “Usando e configurando o ssh”)
  • Go (golang.org) (consulte “Instalando o Go”)
  • Docker (consulte Instalando o Docker e o containerd”
  • Ferramentas de compilação (consulte “Instalando as ferramentas de compilação”
  • O jq, um processador JSON, (consulte “Instalando o jq”
  • O python-pip e o pyyaml (consulte “Instalando o python-pip e o pyyaml”
  • O etcd

Se você já tiver tudo isso configurado da maneira desejada, fique à vontade para avançar para a etapa “GitHub e o projeto Kubernetes”.

Configurando o sistema operacional host

A primeira coisa a fazer é instalar o Ubuntu em algum local. O Ubuntu LTS Server ou Desktop 16.04 ou 18.04 será suficiente. Se desejar, também é possível usar as liberações mais recentes que não sejam LTS. Eu estou executando o LTS Desktop 16.04 em uma máquina virtual (VM) no iMac por meio do Virtual Box mais recente, o LTS Desktop 18.04 no laptop Mac por meio do Virtual Box e o LTS Server 18.04 em servidores bare metal montados com a maioria das peças usadas.

Certamente é possível usar máquinas virtuais para o desenvolvimento do Kubernetes e eu uso, portanto, não desanime se você não tem os recursos necessáriospara construir seu próprio servidor.

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

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

  • Memória base de 8 G
  • 140 G de unidade de disco rígido vdi
  • Área de transferência compartilhada – somente bidirecional (em caso de desktop)
  • Memória de vídeo de 128 MB (em caso de desktop)
  • Rede: NAT
  • As adições de guest devem ser instaladas (clique em VirtualBox VM > Devices > Insert Guest Additions CD Image… em caso de desktop)
  • Regras de encaminhamento de porta (veja o botão na seção avançada Network):

    Regras de encaminhamento de porta no Virtual Box

Configurando o Ubuntu

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

Terminal do Ubuntu

Em seguida, execute o atualizador de software:

Atualizador de software do Ubuntu

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

A execução do comando apt-get de um terminal

Usando e configurando o ssh

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

Use o cliente PC ou Mac para conectar-se com ssh ao Ubuntu Server ou Desktop. Se você instalou o Ubuntu Desktop e deseja executar o ssh, execute os comandos a seguir:

$ sudo apt-get install openssh-server
$ sudo service ssh start or sudo /etc/init.d/ssh start
$ ssh -v localhost

Em seguida, efetue login no servidor ssh usando a máquina cliente (com uma senha):

Efetue login no servidor ssh

Para usar opcionalmente o ssh sem senha, conclua as etapas a seguir:

A execução de testes do Kubernetes de ponta a ponta costumava exigir a configuração do ssh sem senha (usando chaves em vez de senhas). Se você não deseja configurar o ssh sem senha, avance para “Instalando o Go”.

Primeiro gere as chaves privadas e públicas do Ubuntu com o comando a seguir:

$ ssh-keygen -t rsa

Em seguida, use o local padrão e insira uma senha ou apenas pressione ENTER:

$ ssh-copy-id mike@10.0.2.15

No Mac, execute o comando a seguir no diretório ~/.ssh para gerar uma chave:

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

Copie e cole a chave pública do Mac (por exemplo, cat ~/.ssh/d_rsa.pub) no ubuntu guest /home/user/.ssh/authorized_keys file.

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

$ sudo nano /etc/ssh/sshd\_config

Faça as seguintes edições em 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, teste-o:

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

Verifique se ele funciona e, em seguida, feche.

Como você efetuará login como raiz sem senha, será possível usar um atalho e copiar as chaves pública e privada do usuário, além das authorized_keys, 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 será possível conectar-se com ssh, raiz ou usuário no Ubuntu guest, sem uma senha, usando sua conta do usuário no terminal Mac:

Terminal 1:

ssh -p 2222 root@127.0.0.1

Terminal 2:

ssh -p 2222 mike@127.0.0.1

Também será possível conectar-se com ssh das contas do usuário ou raiz no host do Ubuntu com as contas do usuário e raiz no host do Ubuntu:

$ ssh root@10.0.2.15
$ sudo ssh root@10.0.2.15

Instalando o Go

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

Escolha a versão que deseja em https://golang.org/dl/ e, em seguida, execute curl (faça o download) para o 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 as variáveis de ambiente para os usuários aplicáveis, por exemplo, o usuário conectado no momento (~):

$ sudo nano ~/.profile
    e
$ sudo nano /root/.profile

Agora, inclua a instrução de caminho de exportação nesses arquivos incluindo esta linha:

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

Observe: /usr/local/go/bin é para executar os binários do Go que são enviados com ele, e /home/username/go/bin¬ é para executar quaisquer aplicativos do Go criados com ele.

Teste a configuração:

$ go version

go version go1.13.9 linux/amd64

Para executar como sudo com suas edições de perfil do usuário, execute o comando a seguir:

$ sudo su --

# source /home/mike/.profile

Embora seja mais arriscado, é possível efetuar login como raiz e mudar o sudo secure_path por meio do visudo para incluir os caminhos para o Go:

# visudo

Edite o sudo padrão secure_path:

Padrões
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 a configuração do sudo:

$ sudo go version

go version go1.13.9 linux/amd64

Instalando o Docker e o containerd

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

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

$ sudo apt-get update

Em seguida, remove 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

Inclua a chave GPG do Docker:

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

Inclua as liberaçõ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 comando a seguir:

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

Teste a instalação do Docker:

$ sudo docker run hello-world

Inclua você mesmo no grupo do Docker que é executado como sudo, para que seja possível executar o Docker sem digitar sudo:

$ sudo usermod -aG docker mike

Reinicie o host do Ubuntu:

$ sudo shutdown -r

Efetue login novamente no host com ssh depois que ele concluir a reinicialização e teste o Docker novamente, desta vez sem o sudo:

$ docker run hello-world

Instalando as ferramentas de compilação

Execute o comando a seguir:

$ sudo apt-get install build-essential

Instalando o jq

Execute o comando a seguir para instalar o jq (um processador de JSON):

$ sudo apt-get install jq

Instalando o python-pip e o pyyaml

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

$ sudo apt-get install python-pip

$ sudo pip install pyyaml

GitHub e o projeto Kubernetes

Primeiro, vamos analisar a derivação e, em seguida, a clonagem das derivações. Depois, haverá várias configurações dos perfis e das configurações do cliente. Finalmente, você aprenderá sobre o fluxo de trabalho do Git para o projeto Kubernetes.

Bifurcação

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

<img src=“https://developer.ibm.com/developer/default/articles/setup-guide-for-kubernetes-developers/images/forking.png” align=”right” width=514 height=256>

Clonando suas bifurcações

Normalmente, ao clonar um repositório de origem do github.com, usa-se 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 facilidade de usar os comandos do tipo get do Go para puxar os pacotes hospedados no GitHub.

No entanto, por motivos anteriores, os pacotes do Kubernetes são denominados k8s.io/kubernetes e não github.com/kubernetes/kubernetes, como seria esperado. Assim, para fazer com que todo esse conjunto de ferramentas de desenvolvimento funcione corretamente, para encontrar o código do pacote no disco, é necessário colocar o clone em um diretório k8s.io.

Crie as árvores de origem k8s.io/kubernetes a partir das suas bifurcações de nome ou do Kubernetes seguindo as etapas a seguir:

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) das bifurcações para os diretórios go/src/k8s.io/kubernetes e k8s.io/website. O Git cria uma ramificação principal no disco rígido local para suas bifurcações de hub do Git.

Verifique o status da sua ramificação:

$ 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:

  • Inclua um e-mail em seu perfil público
  • Ative a autenticação de dois fatores

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

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

Configure as entradas user.* para global e/ou local:

$ 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"

Facilite o push:

$ git config --global push.default simple

Execute o comando a seguir para que não seja necessário lembrar as credenciais do GitHub toda vez:

$ git config credential.helper store

Peça para o Git rastrear as mudanças na ramificação clonada no 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 esta:

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 do Git para o projeto de software livre do Kubernetes

O diagrama a seguir mostra um fluxo de trabalho típico do Git para localizar e corrigir um problema com um produto de software livre no GitHub. Embora essa fluxo tenha sido criado para o Docker, ele também funciona para o Kubernetes.

A execução do comando apt-get de um terminal

Encontre algo em que deseja trabalhar aqui nos problemas do Kubernetes: https://github.com/kubernetes/kubernetes/issues

Captura de tela dos problemas no software livre do Kubernetes

Faça um comentário no problema encontrado.

Em caso de dúvidas, entre em contato.

Se desejar trabalhar nele, basta informar. Por exemplo, inclua uma frase dizendo que está chamando #dibs, para indicar que você está trabalhando nesse problema.

Se você não tiver certeza se consegue corrigir esse problema, pelo menos informe que está investigando, com #investigating. Você não é designado, mas informa os outros participantes de que você poderá chamar dibs mais tarde.

Desenvolvimento do Kubernetes (instalando o etcd)

Antes de desenvolver o Kubernetes, é necessário instalar o etcd. O script a seguir é incluído com o Kubernetes para instalar o etcd:

$ hack/install-etcd.sh

Inclua o caminho exibido no etcd para seus perfis do usuário. Por exemplo, inclua /home/mike/go/src/k8s.io/kubernetes/third_party/etcd em seus caminhos com o seguinte comando:

$ sudo nano ~/.profile

$ sudo nano /root/.profile

E, caso deseje, inclua isso no secure\_path para o sudo:

$ sudo su -
# visudo

Agora, o caminho seguro deve ser semelhante a este:

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 o host:

$ sudo shutdown -r

Efetue login novamente no host com ssh depois que ele concluir a reinicialização e teste o etcd:

$ etcd --version
$ sudo etcd --version

Desenvolvendo o Kubernetes com o Make

Use o destino de ajuda para mostrar as opções do Make:

$ make help

Renúncias de responsabilidade e avisos: na primeira vez que você compila, verifica e testa, o Kubernetes demora bastante porque está compilando e transferindo por download um número significativos de imagens de contêiner grandes. Alguns downloads poderão falhar, causando falhas inesperadas de compilação e de teste na primeira e, talvez, na segunda vez que você tentar executá-los. Além disso, como você estará resolvendo a compilação, erros “principais” podem ser esperados em parte dos testes ou em muitos deles, e alguns erros somente podem ocorrer após um longo tempo limite, portanto, tenha paciência. Mesmo se tudo já tiver sido transferido por download e não houver erros, as etapas de compilação, verificação e teste poderão demorar um tempo significativo.

Se você deseja compilar tudo para executar o Kubernetes localmente, use o destino all:

$ sudo make all

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

$ sudo make WHAT=cmd/kublet

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

$ sudo make clean

Para gerar uma liberação, execute o comando a seguir:

$ sudo make release

To generate a release without running tests, run the following command:

$ sudo make release-skip-tests

Testando o Kubernetes (unidade e integração)

Antes de confirmar as mudanças na ramificação de desenvolvimento local, recomenda-se que você execute os testes de verificação, unidade e integração. Dependendo do tipo de mudança, também é possível executar buckets de teste de ponta a ponta.

Testes de verificação de compilação (por exemplo, verificação de pré-envio) a serem realizados antes de enviar uma PR por push para kubernetes/kubernetes:

$ sudo make verify

Execute o comando a seguir para os testes de unidade:

$ sudo make test

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

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

Execute apenas os testes do kubelet no modo detalhado:

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

Execute os testes de pod e do kubelet no modo detalhado:

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

Execute o comando a seguir para os testes de integração:

$ sudo make test-integration

Execute o comando a seguir para os testes de integração do kubelet:

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

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

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

Testes de ponta a ponta do Kubernetes

As seções a seguir mostram como executar testes de ponta a ponta ou de e2e do Kubernetes.

1. Instalar o kubetest

Execute os comandos a seguir para instalar o kubetest:

$ cd ../test-infra
$ sudo GO111MODULE=on go install ./kubetest
$ cd ../kubernetes

2. Ative um cluster local

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

Uma observação sobre o teste de ponta a ponta: com as opções de teste de e2e padrão, quando a versão do cliente e do servidor não estiverem sincronizadas, os testes de e2e não funcionarão. Agora é possível executar o e2e com as versões sem defasagem usando a configuração check_version_skew=false.

No terminal 1, compile o Kubernetes e inicie o cluster local:

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

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

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

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

$ cluster/kubectl.sh get nodes

NAME        STATUS    AGE
127.0.0.1   Ready     3h

3. Execute os testes de e2e

No terminal 2, execute o bucket de teste de segredos do e2e:

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

Observação: o minStartupPods está configurado como 1 para refletir que há apenas um nó no cluster local.

Agora, execute todos os testes de e2e (isso demora bastante para ser concluído):

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

Ao concluir o uso do cluster do Kubernetes, é possível desativá-lo rapidamente com ctrl-C no terminal 1.

Para obter mais informações sobre os testes de ponta a ponta, consulte e2e-tests.

Testes de nó de ponta a ponta do Kubernetes

As seções a seguir mostram como executar os testes de nó de ponta a ponta do Kubernetes, também conhecidos como testes de e2e-node.

1. Instale o ginkgo

Execute os comandos a seguir:

$ 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 o cluster de nó único local:

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

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

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

3. Execute os testes de e2e-node

Execute os testes Sysctls e2e-node localmente:

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

Execute todos os e2e-node tests (esta etapa demora bastante para ser concluída):

$ sudo make test-e2e-node PARALLELISM=1

Mais informações sobre os testes de nós de ponta a ponta estão disponíveis em e2e-node-tests .

Compilando os arquivos gerados

Depois de editar os arquivos de origem usados na geração de outros arquivos de origem na árvore kubernetes/kubernetes, deve-se atualizar os arquivos gerados antes de executar uma confirmação do git. Execute o comando a seguir:

$ sudo make update

Running update-generated-protobuf
Running update-codegen
Running update-generated-runtime
Running update-generated-device-plugin
...

O website da documentação do Kubernetes

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

Outras coisas a fazer

O trabalho ainda não terminou. Aqui estão algumas outras tarefas que devem ser realizadas:

  • Execute gofmt -s -w file.go em cada arquivo alterado antes de confirmar as mudanças.
  • Execute golint em cada arquivo alterado antes de confirmar as mudanças. (A equipe do Kubernetes não usa o lint no momento. Mas seu uso não atrapalha.)
  • Lembre-se de atualizar a documentação ao criar ou modificar recursos.
  • Lembre-se de incluir casos de teste para abordar suas mudanças.
  • As confirmações que corrigem ou encerram um problema devem referenciá-lo na mensagem de confirmação: Closes #XXXX ou Fixes #XXXX.
  • Após cada confirmação, execute o suíte de testes e certifique-se de que ele seja aprovado.
  • Sincronize e rebaseie com frequência durante a codificação, para atualizar o mestre.

Resumo

Espero que este guia o tenha ajudado a começar sua jornada de desenvolvimento do Kubernetes. Revise e siga as Diretrizes da comunidade do Kubernetes para garantir o sucesso como contribuidor, membro, revisor, aprovador (ou seja, “responsável”, “mantenedor”) e/ou subproprietário de projeto.

É possível entrar em contato comigo pelos seguintes canais: brownwm@us.ibm.com e https://twitter.com/mikebrow.

Aviso

O conteúdo aqui presente foi traduzido da página IBM Developer US. Caso haja qualquer divergência de texto e/ou versões, consulte o conteúdo original.