Kubernetes - Configuração

É importante configurar o Virtual Datacenter (vDC) antes de configurar o Kubernetes. Isso pode ser considerado um conjunto de máquinas onde elas podem se comunicar através da rede. Para uma abordagem prática, você pode configurar o vDC onPROFITBRICKS se você não tiver uma infraestrutura física ou em nuvem configurada.

Assim que a configuração de IaaS em qualquer nuvem estiver concluída, você precisa configurar o Master e a Node.

Note- A configuração é mostrada para máquinas Ubuntu. O mesmo pode ser configurado em outras máquinas Linux também.

Pré-requisitos

Installing Docker- O Docker é necessário em todas as instâncias do Kubernetes. A seguir estão as etapas para instalar o Docker.

Step 1 - Faça logon na máquina com a conta de usuário root.

Step 2- Atualize as informações do pacote. Certifique-se de que o pacote apt está funcionando.

Step 3 - Execute os seguintes comandos.

$ sudo apt-get update
$ sudo apt-get install apt-transport-https ca-certificates

Step 4 - Adicione a nova chave GPG.

$ sudo apt-key adv \
   --keyserver hkp://ha.pool.sks-keyservers.net:80 \
   --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
$ echo "deb https://apt.dockerproject.org/repo ubuntu-trusty main" | sudo tee
/etc/apt/sources.list.d/docker.list

Step 5 - Atualize a imagem do pacote de API.

$ sudo apt-get update

Depois que todas as tarefas acima forem concluídas, você pode começar com a instalação real do mecanismo Docker. No entanto, antes disso, você precisa verificar se a versão do kernel que está usando está correta.

Instale o Docker Engine

Execute os comandos a seguir para instalar o mecanismo Docker.

Step 1 - Faça logon na máquina.

Step 2 - Atualize o índice do pacote.

$ sudo apt-get update

Step 3 - Instale o Docker Engine usando o seguinte comando.

$ sudo apt-get install docker-engine

Step 4 - Inicie o daemon Docker.

$ sudo apt-get install docker-engine

Step 5 - Para saber se o Docker está instalado, use o seguinte comando.

$ sudo docker run hello-world

Instale o etcd 2.0

Isso precisa ser instalado na máquina mestre do Kubernetes. Para instalá-lo, execute os seguintes comandos.

$ curl -L https://github.com/coreos/etcd/releases/download/v2.0.0/etcd
-v2.0.0-linux-amd64.tar.gz -o etcd-v2.0.0-linux-amd64.tar.gz ->1
$ tar xzvf etcd-v2.0.0-linux-amd64.tar.gz ------>2
$ cd etcd-v2.0.0-linux-amd64 ------------>3
$ mkdir /opt/bin ------------->4
$ cp etcd* /opt/bin ----------->5

No conjunto de comandos acima -

  • Primeiro, baixamos o etcd. Salve com o nome especificado.
  • Então, temos que descompactar o pacote tar.
  • Nós fazemos um dir. dentro do bin nomeado / opt.
  • Copie o arquivo extraído para o local de destino.

Agora estamos prontos para construir o Kubernetes. Precisamos instalar o Kubernetes em todas as máquinas do cluster.

$ git clone https://github.com/GoogleCloudPlatform/kubernetes.git
$ cd kubernetes
$ make release

O comando acima irá criar um _outputdir na raiz da pasta kubernetes. Em seguida, podemos extrair o diretório em qualquer diretório de nossa escolha / opt / bin, etc.

Em seguida, vem a parte da rede em que precisamos realmente começar com a configuração do mestre e do nó do Kubernetes. Para fazer isso, faremos uma entrada no arquivo host que pode ser feito na máquina do nó.

$ echo "<IP address of master machine> kube-master
< IP address of Node Machine>" >> /etc/hosts

A seguir será a saída do comando acima.

Agora, começaremos com a configuração real no Kubernetes Master.

Primeiro, começaremos a copiar todos os arquivos de configuração para seus locais corretos.

$ cp <Current dir. location>/kube-apiserver /opt/bin/
$ cp <Current dir. location>/kube-controller-manager /opt/bin/
$ cp <Current dir. location>/kube-kube-scheduler /opt/bin/
$ cp <Current dir. location>/kubecfg /opt/bin/
$ cp <Current dir. location>/kubectl /opt/bin/
$ cp <Current dir. location>/kubernetes /opt/bin/

O comando acima irá copiar todos os arquivos de configuração para o local necessário. Agora vamos voltar para o mesmo diretório em que criamos a pasta Kubernetes.

$ cp kubernetes/cluster/ubuntu/init_conf/kube-apiserver.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-controller-manager.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-kube-scheduler.conf /etc/init/

$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-apiserver /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-controller-manager /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-kube-scheduler /etc/init.d/

$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/

A próxima etapa é atualizar o arquivo de configuração copiado em / etc. dir.

Configure o etcd no master usando o seguinte comando.

$ ETCD_OPTS = "-listen-client-urls = http://kube-master:4001"

Configurar kube-apiserver

Para isso no mestre, precisamos editar o /etc/default/kube-apiserver arquivo que copiamos anteriormente.

$ KUBE_APISERVER_OPTS = "--address = 0.0.0.0 \
--port = 8080 \
--etcd_servers = <The path that is configured in ETCD_OPTS> \
--portal_net = 11.1.1.0/24 \
--allow_privileged = false \
--kubelet_port = < Port you want to configure> \
--v = 0"

Configure o gerenciador de controle kube

Precisamos adicionar o seguinte conteúdo em /etc/default/kube-controller-manager.

$ KUBE_CONTROLLER_MANAGER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--machines = kube-minion \ -----> #this is the kubernatics node
--v = 0

Em seguida, configure o agendador kube no arquivo correspondente.

$ KUBE_SCHEDULER_OPTS = "--address = 0.0.0.0 \
--master = 127.0.0.1:8080 \
--v = 0"

Depois que todas as tarefas acima forem concluídas, podemos prosseguir, trazendo o mestre do Kubernetes. Para fazer isso, reiniciaremos o Docker.

$ service docker restart

Configuração de nó do Kubernetes

O nó do Kubernetes executará dois serviços, kubelet and the kube-proxy. Antes de prosseguir, precisamos copiar os binários baixados para as pastas necessárias, onde queremos configurar o nó do kubernetes.

Use o mesmo método de copiar os arquivos que fizemos para o mestre do kubernetes. Como ele só executará o kubelet e o kube-proxy, iremos configurá-los.

$ cp <Path of the extracted file>/kubelet /opt/bin/
$ cp <Path of the extracted file>/kube-proxy /opt/bin/
$ cp <Path of the extracted file>/kubecfg /opt/bin/
$ cp <Path of the extracted file>/kubectl /opt/bin/
$ cp <Path of the extracted file>/kubernetes /opt/bin/

Agora, vamos copiar o conteúdo para o diretório apropriado.

$ cp kubernetes/cluster/ubuntu/init_conf/kubelet.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/init_conf/kube-proxy.conf /etc/init/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kubelet /etc/init.d/
$ cp kubernetes/cluster/ubuntu/initd_scripts/kube-proxy /etc/init.d/
$ cp kubernetes/cluster/ubuntu/default_scripts/kubelet /etc/default/
$ cp kubernetes/cluster/ubuntu/default_scripts/kube-proxy /etc/default/

Vamos configurar o kubelet e kube-proxy conf arquivos.

Vamos configurar o /etc/init/kubelet.conf.

$ KUBELET_OPTS = "--address = 0.0.0.0 \
--port = 10250 \
--hostname_override = kube-minion \
--etcd_servers = http://kube-master:4001 \
--enable_server = true
--v = 0"
/

Para kube-proxy, iremos configurar usando o seguinte comando.

$ KUBE_PROXY_OPTS = "--etcd_servers = http://kube-master:4001 \
--v = 0"
/etc/init/kube-proxy.conf

Por fim, reiniciaremos o serviço Docker.

$ service docker restart

Agora terminamos a configuração. Você pode verificar executando os seguintes comandos.

$ /opt/bin/kubectl get minions