Guia de configuração para desenvolvedores Kubernetes - TecMundo
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.
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?
Kubernetes está disponível no GitHub.
O Kubernetes é um OSS?
Kubernetes é um software de código aberto e foi doado peao Google para a Cloud Native Computing Foundation (CNCF).
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.
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.
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.
Um terminal Linux, ssh ou ambos (consulte Configurando seu sistema operacional host, Configurando o Ubuntu e Utilizando e configurando o ssh);
Go (golang.org; consulte Instalando o Go);
Docker (consulte Instalando Docker e containerd);
Build tools (consulte Instalando build tools);
jq, um processador JSON (consulte Instalando o jq);
python-pip e pyyaml (consulte Instalando o python-pip e o pyyaml);
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:
Baixe e instale o Virtual Box: https://www.virtualbox.org/wiki/Downloads
Baixe um arquivo ISO do Ubuntu (servidor/desktop): http://www.ubuntu.com/
Crie uma nova vbox usando o ISO do Ubuntu que você acabou de baixar.
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):
Se você estiver usando o Ubuntu Desktop, crie 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:
Em seguida, faça o login em seu servidor ssh a partir de sua máquina cliente (com uma senha):
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:
Em seguida, utilize o local-padrão e digite uma senha ou apenas pressione ENTER:
Em seu Mac, execute o seguinte comando no diretório ~/.ssh para gerar uma chave:
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:
Faça as seguintes edições para UN-comment/configure:
Em seguida, faça o teste:
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:
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:
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:
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:
Configure variáveis de ambiente para usuários aplicáveis, por exemplo, o usuário atualmente conectado (~):
Agora você adiciona a instrução de caminho de exportação a esses arquivos acrescentando esta linha:
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.
Para executar como sudo com as edições de seu perfil de usuário, execute o seguinte comando:
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:
Edite o secure_path padrão do sudo:
Teste sua configuração de sudo:
Para obter mais informações, consulte Instalar o Docker Engine no Ubuntu.
Para instalar o Docker, primeiro você atualiza seus pacotes:
Em seguida, remova todas as versões anteriores:
Adicione a chave GPG do Docker:
Adicione as versões estáveis do Docker como um repositório apt:
Para escolher uma versão específica do Docker, execute o seguinte comando:
Adicione-se ao grupo Docker que é executado como sudo para que possa executar o Docker sem digitar sudo:
Reinicie seu host Ubuntu:
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:
Instalando build tools
Instalando jq
Execute o seguinte comando para instalar o jq (um processador JSON):
Execute os seguintes comandos para instalar o python-pip e o pyyaml:
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.
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:
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:
Adicione um e-mail ao seu perfil público;
Recomendações de configuração do cliente Git
Defina as entradas user. * como global, local ou ambos:
Torne o push mais fácil:
Execute o seguinte comando para não ter que lembrar de suas credenciais do GitHub todas as vezes:
Diga ao git para rastrear alterações no branch clonado em seu disco rígido em relação a kubernetes/kubernetes:
A execução de git config -l deve ser semelhante a:
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.
Encontre algo para trabalhar aqui, nos problemas do Kubernetes: https://github.com/kubernetes/kubernetes/issues
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:
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:
E, se quiser, adicione-o ao seu secure\_path para sudo:
Agora, o caminho seguro deve ser exibido assim:
Reinicie seu host:
Faça login novamente em seu host com ssh após a reinicialização do host e teste o etcd:
Desenvolvendo o Kubernetes com make
Use o alvo de ajuda para mostrar as opções de make:
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:
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:
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:
Para gerar uma versão, execute o seguinte comando:
Para gerar uma versão sem executar testes, execute o seguinte comando:
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:
Execute o seguinte comando para testes de unidade:
Execute o seguinte comando apenas para os testes pkg/api/pod:
Execute apenas os testes de kubelet no modo detalhado:
Execute os testes de pod e kubelet no modo detalhado:
Execute o seguinte comando para testes de integração:
Execute o seguinte comando para testes de integração do kubelet:
Execute os testes de integração do pod em modo detalhado:
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:
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:
No terminal 2, configure kubectl para interagir com seu cluster local:
Verifique o status do seu cluster local de nó único:
127.0.0.1 Ready 3h
3. Execute os testes e2e
No terminal 2, execute o bloco de teste e2e 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):
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.
No terminal 1, inicie seu cluster de nó único local:
3. Execute os testes do nó e2e
Execute os testes do nó Sysctls e2e localmente:
Execute todos os testes do nó e2e (esta etapa leva bastante tempo para ser concluída):
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:
O site de documentação do Kubernetes
Se você quiser contribuir com a documentação do Kubernetes, siga estas instruções.
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.
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.