Este tutorial irá guiá-lo na configuração de um Kubernetes cluster do zero usando Ansible e Kubeadm e, posteriormente, na implantação de uma aplicação Nginx conteinerizada com ele.
Introdução
Kubernetes (também conhecido como k8s ou “kube”) é uma plataforma de orquestração de contêineres de código aberto que automatiza muitos dos processos manuais envolvidos na implantação, gerenciamento e dimensionamento de aplicações conteinerizadas. O Kubernetes possui uma comunidade de código aberto em rápido crescimento, que contribui ativamente para o projeto. Dê uma olhada no nosso post do blog que apresentará tudo o que você precisa saber sobre os conceitos básicos da plataforma Kubernetes.
Kubeadm é uma ferramenta que configura vários elementos, partes e peças integradas, como o servidor de API, o Controller Manager e o Kube DNS. Ela também ajuda a automatizar a instalação. No entanto, ela não cria usuários nem lida com a instalação de dependências no nível do sistema operacional e sua configuração, e não pode provisionar sua infraestrutura.
Ansible é uma ferramenta de código aberto para provisionamento de software e implantação de aplicações. Saltstack é um software de código aberto para automação de tecnologia da informação orientada a eventos. Estas são as duas ferramentas que tornam a criação de clusters adicionais ou a recriação de clusters existentes menos vulnerável a erros e podem ser usadas para essas tarefas preliminares.
Objetivos:
Seu cluster incluirá os seguintes recursos físicos:
1. Um nó master:
Um nó master é um nó que controla e gerencia um conjunto de nós de trabalho (workloads runtime) e se assemelha a um cluster no Kubernetes. Ele também mantém o plano de recursos do nó para determinar a ação apropriada para o evento acionado. Ele executa o etcd, um armazenamento de chave-valor distribuído de código aberto usado para manter e gerenciar dados do cluster entre componentes que agendam cargas de trabalho para nós de trabalho.
Por exemplo, the scheduler determinaria qual nó de trabalho hospedará um POD recém-agendado.
2. Dois nós de trabalho:
Os nós de trabalho são os nós que continuam com o trabalho atribuído mesmo que o nó master fique inativo após a conclusão do agendamento. Os nós de trabalho são os servidores onde suas cargas de trabalho (ou seja, aplicações e serviços conteinerizados) serão executadas. Você também pode aumentar a capacidade do cluster adicionando workers.
Depois de concluir este tutorial, você terá um cluster totalmente funcional pronto para executar cargas de trabalho (ou seja, aplicações e serviços conteinerizados), assumindo que os servidores no cluster tenham recursos de CPU e RAM suficientes para a execução de suas aplicações. Depois de configurar o cluster com sucesso, você poderá executar quase qualquer aplicação UNIX tradicional. Ela poderá ser conteinerizada em seu cluster, incluindo aplicações web, bancos de dados, daemons e ferramentas de linha de comando.
O cluster em si consumirá cerca de 300-500MB de memória e 10% de CPU em cada nó.
Pré-requisitos:
- Você deve ter um par de chaves SSH em sua máquina Linux local e saber como usar chaves SSH. No entanto, se você nunca usou chaves SSH antes, pode consultar este tutorial para ajudá-lo a configurar chaves SSH em sua máquina local.
- Três servidores executando Ubuntu 18.04 com pelo menos 4GB RAM e 4 vCPUs cada. Você deve ser capaz de acessar cada servidor via SSH como usuário root com seu par de chaves SSH. Siga este tutorial para instalar seu servidor Ubuntu.
- Ansible instalado em sua máquina local.
- Você também deve estar familiarizado com os playbooks do Ansible.
- Você também precisará saber como iniciar um contêiner a partir de uma imagem Docker. Consulte “Passo 5 — Trabalhando com Imagens Docker no Ubuntu” em Como Instalar e Usar o Docker no Ubuntu 18.04 se precisar de uma recapitulação.
Passo 1 — Configurando o Diretório do Espaço de Trabalho e o Arquivo de Inventário do Ansible
Primeiro, você precisa configurar o Ansible em sua máquina local. Ele ajudará você a executar comandos em seu servidor remoto. Também facilita o esforço de implantação manual ao automatizá-lo. Para isso, você precisará criar um diretório em sua máquina local que servirá como sua área de armazenamento digital temporária (Workspace).
Depois de criar um diretório, você criará um hosts arquivo para armazenar todas as informações sobre os endereços IP e o grupo de cada servidor. Ele ajudará você a armazenar as informações de inventário dentro dele. Como mencionado anteriormente, haveria três servidores, um master e dois workers. O servidor master será o master com um IP exibido como master_ip. Os outros dois servidores serão workers e terão os IPs worker_1_ip e worker_2_ip.
Você precisa criar um diretório chamado ~/kube-cluster no diretório home da sua máquina local e entrar no diretório usando o comando cd nele:
|
1 2 |
mkdir ~/kube-cluster cd ~/kube-cluster |
O ~/kube-cluster diretório agora funcionará como a área de armazenamento digital temporária (espaço de trabalho) dentro da qual você executará todos os comandos locais para criar um cluster Kubernetes usando o kubeadm. O diretório conterá todos os seus playbooks do Ansible e será usado no restante do tutorial.
Criando o Arquivo Hosts
Crie um arquivo chamado ~/kube-cluster/hosts usando o nano ou seu editor de texto favorito:
|
1 |
nano ~/kube-cluster/hosts |
Agora você precisará adicionar o seguinte texto, que especificará informações sobre a estrutura lógica do seu cluster:
|
1 2 3 4 5 6 7 8 9 |
[masters] master ansible_host=master_ip ansible_user=root [workers] worker1 ansible_host=worker_1_ip ansible_user=root worker2 ansible_host=worker_2_ip ansible_user=root [all:vars] ansible_python_interpreter=/usr/bin/python3 |
Como mencionado, esse arquivo de inventário ajudará você a armazenar todas as informações sobre os endereços IP dos seus servidores e os grupos aos quais cada servidor pertence. ~/kube-cluster/hosts será o seu arquivo de inventário e (masters e workers) serão os dois grupos do Ansible que você adicionou a ele, especificando a estrutura lógica do seu cluster.
O grupo Master é o grupo que especifica que o Ansible deve executar comandos remotos como o usuário root. Ele também lista o IP do nó master (master_ip) que pode ser listado pela entrada do servidor chamada “master”. Da mesma forma, o grupo Workers possui duas entradas para os servidores workers (worker_1_ip e worker_2_ip) que também especificam o ansible_user como root.
A última linha do arquivo diz ao Ansible para usar os interpretadores Python 3 dos servidores remotos para suas operações de gerenciamento. Por fim, você precisa salvar e fechar o arquivo após adicionar o texto. Depois de configurar o diretório do espaço de trabalho e o arquivo de inventário do Ansible, vamos passar para a próxima etapa de instalação das dependências no nível do sistema operacional e criação das configurações.
Etapa 2 — Criando um Usuário Não-Root em Todos os Servidores Remotos
Nesta etapa, você aprenderá como criar um usuário não-root com privilégios sudo em todos os servidores para que possa fazer SSH neles manualmente como um usuário sem privilégios.
Isso pode ser útil para operações executadas com frequência para a preservação de um cluster. Além disso, esta etapa ajudará você a realizar a tarefa com mais precisão e menos propensa a erros, diminuindo as chances de alterar ou excluir arquivos importantes involuntariamente. Se você quiser alterar a configuração de arquivos pertencentes ao root ou ver informações do sistema com comandos como top/htop e visualizar uma lista de contêineres em execução, a etapa a seguir ajudará você a realizar todas as tarefas.
Criando o Playbook
Crie um arquivo chamado ~/kube-cluster/initial.yml no espaço de trabalho:
|
1 |
nano ~/kube-cluster/initial.yml |
Em seguida, você precisa adicionar a seguinte play. Uma play no Ansible é uma coleção de etapas a serem executadas que visam servidores e grupos específicos. Pode haver uma ou muitas plays em um playbook.
A seguinte play criará um usuário sudo não-root:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
- hosts: all become: yes tasks: - name: criar o 'ubuntu' usuário user: name=ubuntu append=yes state=present createhome=yes shell=/bin/bash - name: permitir que 'ubuntu' tenha sudo sem senha lineinfile: dest: /etc/sudoers line: 'ubuntu ALL=(ALL) NOPASSWD: ALL' validate: 'visudo -cf %s' - name: configurar as chaves autorizadas para o usuário ubuntu authorized_key: user=ubuntu key="{{item}}" with_file: - ~/.ssh/id_rsa.pub |
A seguir, apresentamos uma análise do que o nosso playbook faz:
- Este playbook criará o usuário não-root
ubuntu. - Como você precisa executar comandos
sudosem solicitação de senha, este play configurará o arquivosudoerspara permitir que o usuárioubuntufaça isso. - O principal objetivo da tarefa acima era permitir que você acesse cada servidor via SSH como um usuário
ubuntu. Este playbook adiciona a chave pública da sua máquina local (geralmente~/.ssh/id_rsa.pub) à lista de chaves autorizadas do usuário remotoubunturemoto.
Agora, após adicionar o texto, você precisa salvar e fechar o arquivo.
Executando o playbook
Depois disso, precisamos executar nosso playbook que criará o usuário não-root ubuntu simplesmente executando em máquinas locais:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/initial.yml |
A execução deste comando levará algum tempo, após o qual você verá a seguinte saída:
Depois que esta etapa for concluída, você poderá prosseguir para a instalação das dependências específicas do Kubernetes na próxima etapa.
Etapa 3 — Instalando as Dependências do Kubernetes
Nesta etapa, você aprenderá como instalar os pacotes em nível de sistema operacional exigidos pelo Kubernetes com o gerenciador de pacotes do Ubuntu.
Estes pacotes são:
- Docker: O Docker é uma plataforma e ferramenta para criar, distribuir e executar contêineres Docker. Você pode configurar o Docker facilmente seguindo nosso tutorial sobre como instalar & operar o Docker no Ubuntu na nuvem pública. No entanto, o suporte para outros runtimes, como rkt, está em desenvolvimento ativo no Kubernetes.
Kubeadm: kubeadm é uma ferramenta de CLI que executa as ações necessárias para colocar um cluster mínimo viável em funcionamento. Isso ajudará você a instalar e construir vários componentes do cluster de maneira padrão.kubelet: O kubelet é o principal “agente de nó” que roda em cada nó e lida com operações em nível de nó.kubectl: kubectl também é uma ferramenta de CLI que se comunica com seu cluster e envia comandos por meio de seu Servidor de API.
Criando o playbook
Crie um arquivo chamado ~/kube-cluster/kube-dependencies.yml no espaço de trabalho:
|
1 |
nano ~/kube-cluster/kube-dependencies.yml |
Agora você precisa adicionar as seguintes plays ao arquivo para instalar os seguintes pacotes em seus servidores:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
- hosts: all become: yes tasks: - name: instalar Docker apt: name: docker.io state: present update_cache: true - name: instalar APT Transport HTTPS apt: name: apt-transport-https state: present - name: adicionar Kubernetes apt-key apt_key: url: https://packages.cloud.google.com/apt/doc/apt-key.gpg validate_certs: false state: present - name: adicionar Kubernetes - repositório APT apt_repository: repo: deb http://apt.kubernetes.io/ kubernetes-xenial main state: present filename: 'kubernetes' - name: instalar kubelet apt: name: kubelet=1.16.0-00 state: present update_cache: true - name: instalar kubeadm apt: name: kubeadm=1.16.0-00 state: present - hosts: master become: yes tasks: - name: instalar kubectl apt: name: kubectl=1.16.0-00 state: present force: yes |
A primeira play no playbook faz o seguinte:
- Esta play ajudará você a instalar pacotes a nível de sistema operacional, o Docker – o runtime de contêiner.
- Ele instala
apt-transport-https, o que permite adicionar fontes HTTPS externas à sua lista de fontes do APT. - Adiciona a apt-key do repositório APT do Kubernetes para verificação de chave.
- Adiciona o repositório APT do Kubernetes à lista de fontes do APT dos seus servidores remotos.
- Instala
kubeletekubeadm.
A segunda play realiza uma tarefa importante e única que inclui instalar o kubectl no seu nó master. Agora, após adicionar o texto, você precisa salvar e fechar o arquivo.
Executando o playbook
Depois disso, precisamos executar nosso playbook simplesmente rodando em máquinas locais:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/kube-dependencies.yml |
A execução deste comando levará algum tempo, após o qual você verá a seguinte saída:
Após a execução, o Docker, kubeadm e kubelet estarão instalados em todos os servidores remotos. O kubectl não é um componente obrigatório e é necessário apenas para executar comandos do cluster. Instalá-lo apenas no nó master faz sentido neste contexto, já que você executará comandos kubectl apenas a partir do master. Note, no entanto, que o kubectl os comandos podem ser executados a partir de qualquer um dos nós de trabalho ou de qualquer máquina onde possam ser instalados e configurados para apontar para um cluster.
Todas as dependências do sistema estão agora instaladas. Vamos configurar o nó mestre e inicializar o cluster.
Passo 4 — Configurando o Nó Mestre
Neste passo, você aprenderá alguns conceitos como Pods e Plugins de Rede de Pod já que o seu cluster incluirá ambos assim que você configurar o seu nó mestre.
Os Pods são os menores e mais básicos objetos implantáveis no Kubernetes. Os Pods contêm um ou mais contêineres, como contêineres Docker. Quando um Pod executa múltiplos contêineres, os contêineres são gerenciados como uma única entidade e compartilham os recursos do Pod.
Cada pod tem seu próprio endereço IP, e um pod em um nó deve ser capaz de acessar um pod em outro nó usando o IP do pod. No entanto, a comunicação entre pods é mais complexa. Ela precisa de um componente separado que possa rotear o tráfego de forma transparente de um pod em um nó para um pod em outro. Os plugins de rede de pod são usados para essa funcionalidade. Muitos plugins de rede de pod estão disponíveis, mas usaremos o Flannel pois é uma opção estável e eficiente.
Criando o Playbook
Crie um playbook do Ansible chamado master.yml na sua máquina local:
|
1 |
nano ~/kube-cluster/master.yml |
Além disso, você precisa adicionar a seguinte play ao arquivo para inicializar o cluster e instalar o Flannel:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
- hosts: master become: yes tasks: - name: inicializar o cluster shell: kubeadm init --pod-network-cidr=10.244.0.0/16 >> cluster_initialized.txt args: chdir: $HOME creates: cluster_initialized.txt become: yes become_user: root - name: criar .kube diretório become: yes become_user: ubuntu file: path: $HOME/.kube state: directory mode: 0755 - name: copiar admin.conf para usuário's kube config copy: src: /etc/kubernetes/admin.conf dest: /home/ubuntu/.kube/config remote_src: yes owner: ubuntu - name: instalar Pod rede become: yes become_user: ubuntu shell: kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/2140ac876ef134e0ed5af15c65e414cf26827915/Documentation/kube-flannel.yml >> pod_network_setup.txt args: chdir: $HOME creates: pod_network_setup.txt |
Aqui está uma análise desta play:
- A primeira tarefa nesta play irá configurar o cluster executando
kubeadm init. Para especificar a sub-rede privada que será atribuída aos IPs dos pods, passamos o argumento--pod-network-cidr=10.244.0.0/16. O Flannel usa a sub-rede acima por padrão. Estamos usando isso para dizer aokubeadmpara usar a mesma sub-rede. - A segunda tarefa é usada para criar um diretório
.kubeem/home/ubuntuInformações de configuração, como os arquivos de chave de administrador, que são necessários para se conectar ao cluster e ao endereço de API do cluster, serão mantidas por este diretório. - A terceira tarefa é usada para copiar o arquivo
/etc/kubernetes/admin.confque foi gerado a partir dokubeadm initpara o diretório home do seu usuário não-root. Isso permitirá que você use okubectlpara acessar o cluster recém-criado. - A última tarefa executa
kubectl applypara instalar oFlannel.kubectl apply -f descriptor.[yml|json]é a sintaxe para dizer aokubectlpara criar os objetos descritos no arquivodescriptor.[yml|json]. O arquivokube-flannel.ymlcontém as descrições dos objetos necessários para configurar oFlannelno cluster.
Agora, após adicionar o texto, você precisa salvar e fechar o arquivo.
Executando o Playbook
Depois disso, você precisa executar nosso playbook simplesmente rodando em máquinas locais:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/master.yml |
A execução deste comando levará algum tempo, após o qual você verá a seguinte saída:
Agora faça SSH nele com o seguinte comando para verificar o status do nó master:
|
1 |
ssh ubuntu@master_ip |
Uma vez dentro do nó master, execute:
|
1 |
kubectl get nodes |
Você verá agora a seguinte saída:
Ao obter a saída acima, você pode declarar que todas as tarefas de configuração foram realizadas pelo nó master e ele pode começar a aceitar nós workers e executar tarefas à medida que entra em um estado Ready. Você pode agora adicionar os workers a partir da sua máquina local.
Passo 5 — Configurando os Nós Workers
Depois de configurar o nó master, agora podemos passar para o nosso próximo passo de configuração dos nós workers. Adicionar nós workers ao cluster pode ser feito simplesmente executando um único comando em cada servidor worker. As informações importantes, como o endereço IP, a porta do servidor de API do master e um token seguro, estão incluídas neste comando. No entanto, você deve notar que nem todos os nós poderão se juntar ao cluster, apenas os nós que passarem o token seguro poderão se juntar ao cluster.
Criando o playbook
Este comando ajudará você a navegar de volta para o seu espaço de trabalho e criar um playbook chamado workers.yml:
|
1 |
nano ~/kube-cluster/workers.yml |
Adicione o seguinte texto ao arquivo para adicionar os workers ao cluster:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
- hosts: master become: yes gather_facts: false tasks: - name: obter comando de junção shell: kubeadm token create --print-join-command register: join_command_raw - name: definir comando de junção set_fact: join_command: "{{ join_command_raw.stdout_lines[0] }}" - hosts: workers become: yes tasks: - name: juntar-se ao cluster shell: "{{ hostvars['master'].join_command }} >> node_joined.txt" args: chdir: $HOME creates: node_joined.txt |
Aqui está o que o playbook faz. Existem duas plays no código acima:
- A primeira play é usada para obter o comando de junção que precisa ser executado nos nós de trabalho. O formato do comando será:
kubeadm join --token sha256:<hash><token><master-ip>:<master-port> --discovery-token-ca-cert-hash sha256:<hash>;. A tarefa precisa obter os valores corretos de token e hash. Assim que obtém a entrada correta, a tarefa a define como um fato para que a segunda play possa acessar essa informação. - A segunda play é escrita apenas para realizar uma única tarefa – fazer com que os dois nós de trabalho façam parte do cluster simplesmente executando o comando de junção em todos os nós de trabalho.
Depois de adicionar o texto, você precisa salvar e fechar o arquivo.
Running the playbook
Depois disso, precisamos executar nosso playbook rodando o seguinte comando nas máquinas de trabalho:
|
1 |
ansible-playbook -i hosts ~/kube-cluster/workers.yml |
A execução deste comando levará algum tempo, após o qual você verá a seguinte saída:
Agora, seu cluster Kubernetes está totalmente configurado e funcional, com os workers prontos para executar cargas de trabalho. Antes de passar para a próxima etapa, vamos verificar se o cluster está funcionando como planejado.
Passo 6 — Verificando o Cluster
Pode haver casos em que um cluster falhe durante a configuração. Pode ser devido a um erro de rede entre o master e o worker, ou um problema no nó. Portanto, precisamos verificar o cluster antes de agendar aplicações e garantir que nenhum mau funcionamento ocorra. Para isso, você precisará verificar o estado atual do cluster a partir do nó master para garantir que os nós estejam prontos. Você pode recuperar a conexão com o seguinte comando se os nós não estiverem prontos ou se você for desconectado:
|
1 |
ssh ubuntu@master_ip |
Use os seguintes comandos para obter o status do cluster:
|
1 |
kubectl get nodes |
A execução deste comando levará algum tempo, após o qual você verá a seguinte saída:
Você precisa verificar se todos os nós que fazem parte do cluster estão no estado pronto. Se alguns nós tiverem Not Ready como o STATUS, isso mostra que os nós de trabalho ainda não terminaram sua configuração. No entanto, antes de executar novamente kubectl get nodes e verificar a saída atualizada, você deve esperar mais cinco a dez minutos. Se alguns dos nós ainda mostrarem Not Ready como seu status, você deve verificar as etapas anteriores e executar novamente os comandos. Somente se os nós tiverem o valor Ready para STATUS, eles farão parte do cluster e estarão prontos para executar cargas de trabalho. Após executar com sucesso o 6º passo, seu cluster está verificado. Agora vamos agendar uma aplicação Nginx de exemplo no cluster.
Passo 7 — Executando uma Aplicação no Cluster
Criando o Deployment
Após criar o cluster com sucesso, você pode implantar qualquer aplicação conteinerizada em seu cluster. Você pode usar os comandos a seguir para outras aplicações conteinerizadas se estiver dentro do nó master. Em seguida, execute o seguinte comando para criar um deployment chamado nginx :
|
1 |
kubectl create deployment nginx --image=nginx |
Você precisa alterar o nome da imagem Docker e quaisquer flags relevantes (como portas e volumes). Para manter as coisas familiares, você pode implantar o Nginx usando deployments e services para ver como as aplicações podem ser implantadas no cluster.
Um deployment do Kubernetes é um objeto de recurso no Kubernetes que fornece atualizações declarativas para aplicativos. Uma implantação permite descrever o ciclo de vida de um aplicativo, como imagem de contêiner, réplicas e a estratégia de atualização. Uma implantação garante que o número desejado de pods esteja em execução e disponível o tempo todo. Se um pod falhar durante o tempo de vida do cluster, ele o gera novamente. O processo de atualização também é totalmente registrado e versionado com opções para pausar, continuar e reverter para versões anteriores. O comando acima para criar uma implantação chamada Nginx ajudará você a implantar um pod com um contêiner a partir da imagem Docker do Nginx do registro do Docker.
Configurando a Node Port
Em seguida, precisamos criar um NodePort. NodePort é uma porta aberta em cada nó do seu cluster. O Kubernetes roteia de forma transparente o tráfego de entrada na NodePort para o seu serviço, mesmo que o seu aplicativo esteja em execução em outro nó. Para isso, podemos usar este comando para criar um recurso NodePort chamado Nginx que exporá o aplicativo publicamente:
|
1 |
kubectl expose deploy nginx --port 80 --target-port 80 --type NodePort |
Um serviço é outro objeto do Kubernetes responsável por expor uma interface para esses pods, o que permite o acesso à rede a partir de dentro do cluster ou entre processos externos e o serviço. Ele pode ser definido como uma abstração no topo do pod que fornece um único endereço IP e nome DNS pelo qual os pods podem ser acessados. Com o serviço, é muito fácil gerenciar a configuração de balanceamento de carga.
Execute o seguinte comando:
|
1 |
kubectl get services |
Isso produzirá um texto semelhante ao seguinte:
Depois de obter a saída, o Kubernetes atribuirá automaticamente uma porta aleatória que é maior que 30000 automaticamente, ao mesmo tempo em que garante que a porta atribuída já não esteja vinculada a outro serviço. A terceira linha da saída acima ajudará você a recuperar a porta na qual o Nginx está sendo executado.
Para verificar se está funcionando, visite http://worker_1_ip:nginx_port ou http://worker_2_ip:nginx_port através de um navegador em sua máquina local. Você verá a conhecida página de boas-vindas do Nginx.
Removendo a Implantação
Se você deseja remover o aplicativo Nginx, precisa primeiro excluir o serviço nginx do nó mestre:
|
1 |
kubectl delete service nginx |
Para verificar se o aplicativo foi finalmente excluído, você precisa executar este comando:
|
1 |
kubectl get services |
Você obterá la seguinte saída:
Depois disso, você precisa excluir a implantação usando o seguinte comando:
|
1 |
kubectl delete deployment nginx |
Você pode usar este comando para verificar se a implantação foi finalmente excluída:
|
1 |
kubectl get deployments |
Conclusão:
Este tutorial ajudará você a configurar corretamente um cluster no Ubuntu 18.04 usando Kubeadm and Ansible. Agora que seu cluster está configurado, você pode facilmente começar a implantar seus próprios aplicativos e serviços.
Aqui está uma lista de links com detalhes adicionais que guiarão você no processo:
- Dockerizando aplicativos – Este link contém exemplos que orientam sobre como carregar aplicativos usando o Docker. Como Dockerizar o PostgreSQL, um serviço CouchDB, etc.
- Visão Geral do Pod – Este link apresenta detalhes sobre como usar um pod, o funcionamento dos pods e como os pods se relacionam com outros objetos do Kubernetes. Os pods são uma parte importante do Kubernetes, portanto, compreendê-los ajudará você a ter sucesso em sua tarefa.
- Visão Geral de Implantações – Ajudará você a aprender sobre implantações. Uma implantação fornece atualizações declarativas para Pods e ReplicaSets. Você aprenderá como atualizar, alternar e reverter uma implantação.
- Visão Geral de Serviços -Este link guiará você sobre os serviços de cobertura, que são outro objeto frequentemente usado em clusters Kubernetes. Um serviço no Kubernetes é uma abstração que define um conjunto lógico de Pods e uma política pela qual você pode acessá-los. Compreender os tipos de serviços e as opções que eles possuem é essencial para executar aplicativos com e sem estado.
Além disso, dê uma olhada em nossos outros tutoriais focados em Docker e Kubernetes que você pode encontrar no nosso blog:
- Conhecendo o Kubernetes
- Limpar recursos do Docker – Imagens, contêineres e volumes
- Como executar o Docker na CloudSigma (com CloudInit) Atualizado
- Instalando e configurando o Docker no CentOS 7
- Como instalar & operar o Docker no Ubuntu na nuvem pública
Também existem muitos outros conceitos importantes, como Volumes, Ingresses, e Secrets que você pode usar ao implantar aplicações em produção.
Boa computação!
Comentários
Nenhum comentário ainda. Seja o primeiro.