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?
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).
Onde o Kubernetes é executado?
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:
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);
etcd
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):
Configurando o Ubuntu
Se você estiver usando o Ubuntu Desktop, crie um terminal:
Em seguida, execute o atualizador de software:
A captura de tela a seguir mostra a execução da 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):
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=
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:
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.
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:
$ 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á!
