Um guia para iniciantes para Kubernetes

O que é Kubernetes?

Kubernetes ou K8s é uma plataforma gratuita e de código aberto para gerenciar ambientes e serviços de aplicativos em contêiner. Kubernetes permite criar aplicativos de contêiner portáteis e altamente extensíveis que são fáceis de implantar e gerenciar. É comumente usado ao lado do Docker para desenvolver um melhor controle de aplicações e serviços de contêineres.

Características de Kubernetes

A seguir, são apresentados os recursos essenciais oferecidos pela Kubernetes:

1. Lançamentos e reversão automatizados, caso ocorram erros.
2. Infraestrutura escalável automática.
3. Escala horizontal
4. Balanceadores de carga
5. Verificações de saúde automatizadas e recursos de autocura.
6. Infraestrutura altamente previsível
7. Montagens e sistema de armazenamento para executar aplicativos
8. Uso eficiente de recursos
9. Cada unidade de Kubernetes está vagamente ligada uma com a outra, e cada uma pode atuar como um componente independente.
10. Gerenciamento automático de componentes de segurança, rede e rede.

Arquitetura de Kubernetes

Compreender a arquitetura Kubernetes o ajudará a obter um conhecimento mais profundo de como trabalhar com Kubernetes.

A seguir, são apresentados componentes de hardware da arquitetura Kubernetes:

Um nó é uma representação de uma única máquina em um cluster de Kubernetes. O nó representa uma única máquina de trabalhador, em uma máquina virtual ou hardware físico.

Cada nó em Kubernetes compreende vários componentes de software Kubernetes, como pods, Kubulet, Kube-Proxy e o tempo de execução do contêiner, como o Docker.

Uma vagem refere. Kubernetes gerencia as respectivas vagens em vez dos recipientes e cria réplicas se uma delas falhar. Os pods fornecem recursos compartilhados, como interfaces de rede e dispositivos de armazenamento.

Recipiente/contêiner-Runtime

Um contêiner é um pacote de software isolado e independente. Um contêiner contém tudo o que é necessário para executar um aplicativo, incluindo o código, as bibliotecas do sistema e outras dependências. Depois que um contêiner é implantado, você não pode alterar o código, pois eles são imutáveis. Por padrão, o tempo de execução do contêiner Kubernetes é fornecido pelo Docker.

Kubelet

O Kubelet é um aplicativo simples que permite a comunicação entre o nó e o nó principal. É responsável por gerenciar as vagens e os contêineres. O nó mestre usa o kubectl para executar as ações necessárias para o nó específico.

Kube-proxy

O Kube-Proxy é um proxy de rede disponível em todos os nós do Kubernetes. Ele gerencia as comunicações de rede dentro e fora do cluster.

Conjunto

Um cluster é uma coleção de nós Kubernetes que agregam seus recursos para criar uma máquina poderosa. Recursos compartilhados pelos nós Kubernetes incluem memória, CPU e discos.

Um cluster de Kubernetes é composto por um nó mestre e outros nós de escravos. O nó principal controla o cluster Kubernetes, incluindo aplicativos de agendamento e escala, empurrando e aplicando atualizações e gerenciando os estados de cluster.

Volumes persistentes

Volumes persistentes são usados ​​para armazenar dados em um cluster de Kubernetes. Volumes persistentes são feitos de O vários volumes dos nós do cluster. Uma vez que um nó no cluster é removido ou adicionado, o nó principal distribui o trabalho com eficiência.

Entrada

A entrada de Kubernetes é um objeto API que permite o acesso ao serviço Kubernetes fora do cluster. A entrada normalmente usa o protocolo HTTP/HTTPS para expor os serviços. Uma entrada é implementada em um cluster usando um controlador de entrada ou um balanceador de carga.

Mestre

O mestre, também conhecido como plano de controle, refere -se ao componente de controle central da arquitetura Kubernetes. É responsável por gerenciar a carga de trabalho e interface a comunicação entre o cluster e seus membros.

O mestre é composto por vários componentes. Esses incluem:

1. Gerente de controle
2. Agendador
3. Servidor API
4. Etcd

Gerente de controle

O gerente de controle ou o gerente de controle de kube é responsável por executar e gerenciar o cluster. O Daemon Control coleta informações sobre o cluster e as relata de volta ao servidor da API.

Agendador

O Kube-Scheduler ou simplesmente o agendador é responsável pela distribuição da carga de trabalho. Ele executa funções como determinar se o cluster é saudável, criação de contêiner e mais.

Ele acompanha recursos como memória e CPU e cronogramas para os nós de computação apropriados.

Servidor API

O Kube-Apiserver é uma interface front-end para o mestre de Kubernetes. Ele permite que você fale com o cluster Kubernetes. Depois que o servidor da API recebe uma solicitação, ele determina se a solicitação é válida e o processa se verdadeiro.

Para interagir com o servidor da API, você precisa usar chamadas de repouso através das ferramentas de controle da linha de comando, como Kubectl ou Kubeadm.

Etcd

O etcd é um banco de dados de valor-chave responsável por armazenar dados de configuração e informações sobre o estado do cluster de Kubernetes. Ele recebe comandos de outros componentes de cluster e executa as ações necessárias.

Correndo Kubernetes

Esta seção abrange como começar com Kubernetes. Esta ilustração é testada em um sistema Debian.

Inicie o terminal e atualize seu sistema.

Atualização de sudo apt-get
Atualização de sudo apt-get

Em seguida, instale vários requisitos, conforme mostrado no comando abaixo:

sudo apt-get install curl gnupg ca certificados apt-transport-https

Instale o docker

Em seguida, precisamos instalar o Docker, pois o Kubernetes o usará como tempo de execução do contêiner. As instruções abaixo são para o sistema operacional Debian. Aprenda a instalar o Docker em seu sistema.

Adicione a chave GPG oficial do Docker:

CURL -FSSL https: // Download.Docker.com/linux/debian/gpg | sudo
GPG--Dearmor -o/usr/share/keyrings/Docker-Archive-Keyring.gpg

Em seguida, configure os repositórios do Docker para as fontes, como mostrado no comando:

eco \
"Deb [arch = amd64 assinado por/usr/share/keyrings/Docker-Archive-Keyring.gpg] https: // download.Docker.com/linux/debian \
$ (lsb_release -cs) estável "| sudo tee/etc/apt/fontes.lista.D/Docker.Lista> /dev /null

Em seguida, atualize e instale o Docker:

sudo apt-get update && sudo apt-get install docker-c containerd.IO Docker-C-Cli

Finalmente, inicie e ative o serviço do Docker

sudo systemctl atability docker.serviço
sudo systemctl start docker.serviço

Instale Kubernetes

Em seguida, precisamos instalar Kubernetes no sistema. Da mesma forma, as instruções deste guia são testadas em um sistema Debian.

Aprenda a instalar Kubernetes no seu sistema

Comece baixando a chave de assinatura do Google Cloud:

sudo curl -fsslo/usr/share/keyrings/kubernetes-archive-keyring.gpg https: // pacotes.nuvem.Google.com/apt/doc/apt-key.gpg

Em seguida, adicione o Kubernetes Repository:

eco "Deb [assinado por/usr/share/keyrings/kubernetes-archive-keyring.gpg] https: // apt.Kubernetes.io/kubernetes-xenial main "| sudo tee/etc/apt/fontes.lista.D/Kubernetes.lista

Finalmente, atualize e instale os componentes do Kubernetes

Atualização de sudo apt-get

Instalação sudo apt-get Kubectl Kubelet Kubeadm Kubernetes Kubernetes-CNI

Initialiaze Kubernetes mestre nó

O próximo passo é iniciar o nó principal do Kubernetes. Antes de fazer isso, é recomendável desligar a troca.

Para fazer isso, use o comando:

SUDO SWAPOFF -A

Depois de desativar a troca, inicialize o nó principal com os comandos:

sudo kubeadm init

Depois que o comando for executado com sucesso, você deve obter três comandos.

Copie e execute os comandos como:

mkdir -p $ home/.Kube \
sudo cp -i/etc/kubernetes/admin.conf $ home/.kube/configuração \
sudo chown $ (id -u): $ (id -g) $ home/.kube/config

Implantar rede de pod

O próximo passo é implantar uma rede de pod. Neste guia, usaremos o AWS VPC CNI para Kubernetes.

Use o comando como:

sudo kubectl Aplicar -f https: // RAW.GithubUserContent.com/aws/amazon-vpc-cni-k8s/v1.8.0/config/v1.8/AWS-K8S-CNI.Yaml

Após a conclusão, verifique se o cluster está em funcionamento executando o comando:

sudo kubectl cluster-info

Seria melhor se você tivesse saída como mostrado:

O plano de controle de Kubernetes está em execução em https: // 192.168.43.29: 6443
COREDNS está sendo executado em https: // 192.168.43.29: 6443/API/V1/Namespaces/Kube-System/Serviços/Kube-DNS: DNS/Proxy

Para mostrar todos os nós de execução, use o comando:

sudo kubectl obtenha nós

Implantar um aplicativo

Vamos implantar um aplicativo MySQL e expor o serviço na porta 3306. Use o comando como mostrado:

sudo kubectl Aplicar -f https: // k8s.IO/Exemplos/Application/MySQL/MySQL-Deployment.Yaml
sudo kubectl expõe a implantação mysql --port = 3306--name = mysql-server

Para mostrar a lista de implantações, use o comando:

Kubectl Obtenha implantações

Para obter informações sobre os pods, use o comando:

sudo kubectl descreve pods

Resumindo

Kubernetes é uma ferramenta robusta de implantação e gerenciamento de contêineres. Este tutorial apenas arranha a superfície dos Kubernetes e suas capacidades.