O Kubernetes foi apresentado em um artigo anterior, “Introdução ao Kubernetes na Amazon Web Services (AWS)”. O Kubernetes também foi discutido em outro artigo, “Using Kubernetes (K8s) on IBM Bluemix”. O Kubernetes pode ser instalado em bare metal em praticamente qualquer sistema operacional, incluindo Fedora, CentOS, Ubuntu e CoreOS para fins de desenvolvimento.
O problema
A instalação do Kubernetes em bare metal envolve a execução de vários comandos para configurar um nó mestre, nós de trabalho, rede de pod e etcd.
A solução
O Kubernetes 1.4 apresenta uma nova ferramenta chamada kubeadm para inicializar um cluster Kubernetes. O kubeadm inicializa um cluster Kubernetes com dois comandos. Depois de instalar o Docker, kubectl e kubelet, o nó mestre pode ser iniciado com kubeadm init e nós de trabalho adicionados com kubeadm join .
Neste artigo, usaremos o seguinte procedimento para instalar e inicializar um cluster Kubernetes e, posteriormente, testar o cluster:
- Inicie três novas instâncias do Ubuntu no Amazon EC2.
- Em todas as instâncias do Ubuntu, instale Docker, kubeadm, kubectl e kubelet.
- Em uma das instâncias do Ubuntu, inicialize o cluster mestre do Kubernetes com o seguinte comando:
kubeadm init
- Aplicar a política de rede do Calico Pod kubeadm/calico.yaml .
- Junte-se às outras duas instâncias do Ubuntu (nós) com master com kubeadm join --token=
- No mestre, três nós são listados com "kubectl get nodes".
- Execute um aplicativo no mestre:
kubectl -s http://localhost:8080 run nginx --image=nginx --replicas=3 --port=80
- Liste os pods:
kubectl get pods -o wide
- Desinstale o cluster Kubernetes.
kubeadm reset
Este artigo tem as seguintes seções:
- Definindo o ambiente
- Instalação do Docker, kubeadm, kubectl e kubelet em cada host
- Inicializando o mestre
- Instalando a rede Calico Pod
- Juntar nós ao cluster
- Instalando um aplicativo de amostra
- Desinstalando o cluster
- Limitações
- Desenvolvimentos adicionais no kubeadm
- Conclusão
Definindo o ambiente
O kubeadm A ferramenta requer as seguintes máquinas executando um Ubuntu 16.04+, HypriotOS v1.0.1+ ou CentOS 7 rodando nelas.
- Uma máquina para o nó mestre
- Uma ou mais máquinas para os nós do trabalhador
Pelo menos 1 GB de RAM é necessário em cada uma das máquinas. Usamos três máquinas Ubuntu em execução no Amazon EC2 para inicializar um cluster com um único nó mestre e dois nós de trabalho. As três máquinas Ubuntu são mostradas na Figura 1.
Figura 1: máquinas Ubuntu
Instalando Docker, kubeadm, kubectl e kubelet em cada host
Nesta seção, instalaremos Docker, kubelet, kubectl e kubeadm em cada uma das três máquinas. Os componentes instalados são discutidos na Tabela 1.
| Componente | Descrição |
| Docker | O tempo de execução do contêiner. A versão 1.11.2 é recomendada e v1.10.3 e v1.12.1 também estão bem. Obrigatório em todas as máquinas do cluster. |
| kubelet | O componente principal do Kubernetes que é executado em todas as máquinas do cluster. Inicia contêineres e pods. Obrigatório em todas as máquinas do cluster. |
| kubectl | A ferramenta de linha de comando para gerenciar um cluster. Necessário apenas no nó mestre, mas útil se instalado em todos os nós. |
| kubeadm | A ferramenta para inicializar um cluster. Obrigatório em todas as máquinas do cluster. |
Tabela 1: Componentes para instalar
Obtenha o Endereço IP Público de cada uma das três máquinas e faça login SSH em cada uma das máquinas:
ssh -i "docker.pem" [email protected] ssh -i "docker.pem" [email protected] ssh -i "docker.pem" [email protected]
Os comandos para instalar os binários devem ser executados como root; portanto, defina o usuário como root.
sudo su -
Execute os seguintes comandos em cada uma das máquinas:
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add - cat <<EOF > /etc/apt/sources.list.d/kubernetes.list deb http://apt.kubernetes.io/ kubernetes-xenial main EOF
O primeiro comando baixa os pacotes necessários para o Kubernetes, conforme mostrado na saída da Figura 2.
Figura 2: Baixando pacotes para Kubernetes
O comando 2 baixa as listas de pacotes dos repositórios e as atualiza com as versões mais recentes dos pacotes.
apt-get update
A saída é mostrada na Figura 3.
Figura 3: Atualizando pacotes de repositório
Em seguida, instale o Docker:
# Install docker if you don't have it already. apt-get install -y docker.io
O Docker é instalado, conforme mostrado na saída do comando na Figura 4.
Figura 4: Instalando o Docker
E, posteriormente, instale o kubelet (componente principal do Kubernetes), kubeadm (ferramenta de inicialização), kubectl (ferramenta de gerenciamento de cluster) e kubernetes-cni (plug-in de rede):
apt-get install -y kubelet kubeadm kubectl kubernetes-cni
A saída dos comandos anteriores é mostrada na Figura 5.
Figura 5: Instalando kubelet, kubeadm, kubectln e kubernetes-cni
Inicializando o mestre
Em seguida, inicialize o mestre no qual o banco de dados etcd e o servidor de API são executados. O kubelet inicia os Pods para executar esses componentes. Execute o seguinte comando que detecta automaticamente os endereços IP:
kubeadm init
Conforme mostrado na saída do comando, primeiro, algumas verificações de pré-voo são executadas para validar o estado do sistema. Subsequentemente, um token mestre/tokens é gerado para ser usado como uma chave de autenticação mútua para nós do trabalhador que desejam ingressar no cluster. Em seguida, uma chave e um certificado autoassinados da Autoridade de Certificação são gerados para fornecer identidades a cada um dos nós no cluster para comunicação com os clientes. Uma chave de servidor de API e um certificado são criados para o servidor de API para comunicação com os clientes. Um util/kubeconfig é criado para o kubelet se conectar ao servidor da API e outro util/kubeconfig arquivo é criado para a administração. Posteriormente, a configuração do cliente da API é criada. A saída do kubeadm init comando é mostrado na Figura 6.
Figura 6: Executando o kubeadm init
Todos os componentes do plano de controle ficam prontos. O primeiro nó fica pronto e uma implantação de teste é feita. Os componentes complementares essenciais kube-discovery, kube-proxy e kube-dns também são criados, conforme mostrado na saída do comando na Figura 7. O mestre do Kubernetes é inicializado com êxito. Um comando com a seguinte sintaxe é gerado; ele deve ser executado em máquinas (nós) que devem ingressar no cluster.
kubeadm join -token=<token> <IP Address of the master node>
O comando anterior deve ser copiado e mantido para uso subsequente em nós do trabalhador.
Figura 7: Mestre do Kubernetes inicializado
Por padrão, os nós mestres não são programáveis e são feitos usando a mancha “dedicada”. O nó mestre pode ser agendado com o seguinte comando:
kubectl taint nodes --all dedicated-
O kubeadm O comando suporta algumas outras opções (consulte a Tabela 2) que não precisamos usar, mas podem ser usadas para substituir o comando padrão.
| Parâmetro de comando | Descrição | Padrão |
| --skip-preflight-checks | Ignora as verificações de comprovação | As verificações de simulação são realizadas |
| --use-kubernetes-version | Define a versão do Kubernetes a ser usada | v1.5.1 |
| --api-advertise-addresses | O comando kubeadm init detecta automaticamente e usa o endereço IP da interface de rede padrão e o usa para gerar certificados para o servidor de API. Este parâmetro de configuração pode ser usado para substituir o padrão por um ou mais endereços IP nos quais o servidor de API deve ser validado. | Detecção automática |
| --api-external-dns-names | Este parâmetro de configuração pode ser usado para substituir a interface de rede padrão por um ou mais nomes de host nos quais o servidor de API deve ser validado. Apenas um dos endereços IP ou nomes DNS externos devem ser usados. | |
| --cloud-provider | Especifica um provedor de nuvem. O gerenciador de nuvem suporta “aws”, “azure”, “cloudstack”, “gce”, “mesos”, “openstack”, “ovirt”, “rackspace” e “vsphere”. A configuração do provedor de nuvem pode ser fornecida no arquivo /etc/kubernetes/cloud-config. Usar um provedor de nuvem também tem a vantagem de usar volumes persistentes e balanceamento de carga. | Sem detecção automática de um provedor de nuvem |
| --pod-network-cidr | Aloca intervalos de rede (CIDRs) para cada nó e é útil para determinadas soluções de rede, incluindo provedores de flanela e nuvem. | |
| --service-cidr | Substitui a sub-rede que o Kubernetes usa para atribuir endereços IP aos pods. O /etc/systemd/system/kubelet.service.d/10-kubeadm.conf também deve ser modificado. | 10.96.0.0/12 |
| --service-dns-domain | Substitui o sufixo do nome DNS para atribuir serviços com nomes DNS; tem o formato | cluster.local |
| --token | Especifica o token a ser usado para autenticação mútua entre o mestre e os nós que ingressam no cluster. | Gerado automaticamente |
Tabela 2: Opções de comando Kubeadm
Instalando a rede Calico Pod
Para que os pods possam se comunicar uns com os outros, um complemento de rede de pods deve ser instalado. Calico fornece uma configuração de instalação hospedada em kubeadm na forma de um ConfigMap em http://docs.projectcalico.org/master/getting-started/kubernetes/installation/hosted/kubeadm/calico.yaml que usaremos nesta seção para instalar uma rede Pod. Execute o seguinte comando no nó mestre para instalar a rede do pod:
kubectl apply -f http://docs.projectcalico.org/master/getting-started/ kubernetes/installation/hosted/kubeadm/calico.yaml
Como alternativa, baixe o calico.yaml e copie para o nó mestre:
scp -i "docker.pem" calico.yaml [email protected]:~
Em seguida, execute o seguinte comando:
kubectl apply -f calico.yaml
Calico e um cluster etcd de nó único são instalados, conforme mostrado na Figura 8.
Figura 8: Instalando a Política do Calico
Em seguida, liste todos os pods em todos os namespaces do Kubernetes.
kubectl get pods --all-namespaces
O kube-dns O pod deve estar em execução, conforme listado na Figura 9.
Figura 9: Como listar pods em todos os namespaces
Juntar nós ao cluster
Nesta seção, juntaremos nós de trabalho ao cluster usando o kubeadm join comando, que tem a seguinte sintaxe:
kubeadm join --token=<token> <master-ip>
Opcionalmente, a kubeadm join comando pode ser executado com o --skip-preflight-checks opção de pular a validação preliminar.
A junção kubeadm O comando usa o token fornecido para se comunicar com o servidor de API e obter o certificado de CA raiz e cria um par de chaves local. Subsequentemente, uma solicitação de assinatura de certificado (CSR) é enviada ao servidor de API para assinatura e o kubelet local é configurado para se conectar ao servidor de API.
Execute o kubeadm join comando copiado da saída do kubeadm init comando em cada uma das máquinas Ubuntu que devem ingressar no cluster.
Primeiro, faça login SSH nas instâncias do Ubuntu:
ssh -i "docker.pem" [email protected]
e
ssh -i "docker.pem" [email protected]
Em seguida, execute o kubeadm join comando. Primeiro, algumas verificações pré-voo são realizadas. O token fornecido é validado. Em seguida, a descoberta do nó é usada. Um cliente de descoberta de informações de cluster é criado e as informações são solicitadas do servidor de API. Um objeto de informações do cluster é recebido e uma assinatura é verificada usando o token fornecido. A assinatura e o conteúdo das informações do cluster são válidos e a descoberta do nó está concluída. Posteriormente, é realizado o bootstrap do nó, no qual os endpoints da API https://10.0.0.129:6443 são usados para estabelecer uma conexão. Subsequentemente, uma solicitação de assinatura de certificado (csr) é feita usando um cliente de API para obter um certificado exclusivo para o nó. Depois que um certificado assinado é recebido do servidor de API, um arquivo de configuração kubelet é gerado. A mensagem “Node join complete” listada na Figura 10 indica que o nó ingressou no cluster.
Figura 10: Unindo um nó ao cluster
Da mesma forma, execute o mesmo comando na outra máquina Ubuntu. O outro nó também se junta ao cluster, conforme indicado pela saída na Figura 11.
Figura 11: Unindo o segundo nó ao cluster
No nó mestre, execute o seguinte comando para listar os nós:
kubectl get nodes
O nó mestre e os dois nós do trabalhador devem ser listados, conforme mostrado na Figura 12.
Figura 12: Como listar nós de cluster do Kubernetes
Instalando um aplicativo de amostra
Em seguida, vamos testar o cluster. Execute o seguinte comando para executar um nginx cluster de pod baseado em três réplicas:
kubectl -s http://localhost:8080 run nginx --image=nginx --replicas=3 --port=80
Liste as implantações:
kubectl get deployments
Liste os pods em todo o cluster:
kubectl get pods -o wide
Exponha a implantação como um serviço do tipo LoadBalancer :
kubectl expose deployment nginx --port=80 --type=LoadBalancer
Liste os serviços:
kubectl get services
A saída dos comandos anteriores indica o nginx a implementação foi criada e os três pods são executados nos dois nós do trabalhador no cluster. Um serviço chamado “nginx” também é criado, conforme mostrado na Figura 13.
Figura 13: Executando um cluster de pod nginx
Copie o IP do cluster do serviço. Execute o comando curl para invocar o serviço:
curl 10.0.0.99
A marcação HTML do serviço obtém a saída, conforme mostrado na Figura 14.
Figura 14: Invocando o serviço nginx
Desinstalando o cluster
Para desinstalar o cluster instalado pelo kubeadm, execute o seguinte comando:
kubeadm reset
O cluster é desinstalado, conforme mostrado na Figura 15.
Figura 15: Como desinstalar/redefinir o cluster do Kubernetes
Limitações
kubeadm tem várias limitações e é recomendado apenas para uso em desenvolvimento. As limitações do kubeadm são as seguintes;
- Apenas alguns sistemas operacionais são compatíveis:Ubuntu 16.04+, CentOS 7, HypriotOS v1.0.1+.
- Não é adequado para uso em produção.
- A integração de provedores de nuvem é experimental.
- É criado um cluster com apenas um único mestre com um único banco de dados etcd. A alta disponibilidade não é compatível, o que implica que o mestre é um ponto único de falha (SPOF).
- As funcionalidades HostPort e HostIP não são suportadas.
- Alguns outros problemas conhecidos quando o kubeadm é usado com RHEL/CentOS 7 e VirtualBox.
Desenvolvimentos adicionais no kubeadm
kubeadm está em alfa no Kubernetes v 1.5 e está em beta desde o Kubernetes 1.6. Pequenas correções e melhorias continuam para mim feitas no kubeadm a cada nova versão do Kubernetes:
- Com o Kubernetes 1.7, as modificações nos recursos internos do cluster instalados com o kubeadm são substituídas ao atualizar da v 1.6 para a v 1.7.
- No Kubernetes 1.8, o token Bootstrap padrão criado com kubeadm init torna-se inválida e é excluída após 24 horas da criação para limitar a exposição da credencial valiosa. A junção kubeadm O comando delega a inicialização TLS para o kubelet iteslf em vez de reimplementar o processo. A inicialização KubeConfig arquivo é gravado em /etc/kubernetes/bootstrap-kubelet-conf com kubeadm join .
Conclusão
Neste artigo, usamos o recurso da ferramenta kubeadm disponível desde o Kubernetes v1.4 para inicializar um cluster do Kubernetes. Primeiro, os binários necessários para Docker, kubectl, kubelet e kubeadm são instalados. Posteriormente, o kubeadm init O comando é usado para inicializar o nó mestre no cluster. Por fim, a junção kubeadm O comando é usado para unir nós do trabalhador ao cluster. Uma amostra nginx aplicativo é executado para testar o cluster.
