<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Gustavo Leitão on Medium]]></title>
        <description><![CDATA[Stories by Gustavo Leitão on Medium]]></description>
        <link>https://medium.com/@gustavo-leitao?source=rss-409b4784a255------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*rnadO_xsvcP_IHpD.</url>
            <title>Stories by Gustavo Leitão on Medium</title>
            <link>https://medium.com/@gustavo-leitao?source=rss-409b4784a255------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 11:23:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gustavo-leitao/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Instalando e configurando um cluster Kubernetes 1.18 no CentOS 8]]></title>
            <link>https://gustavo-leitao.medium.com/instalando-e-configurando-um-cluster-kubernetes-1-18-no-centos-8-53cbd29659d1?source=rss-409b4784a255------2</link>
            <guid isPermaLink="false">https://medium.com/p/53cbd29659d1</guid>
            <category><![CDATA[kubbernetes]]></category>
            <category><![CDATA[centos-8]]></category>
            <category><![CDATA[installation]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Gustavo Leitão]]></dc:creator>
            <pubDate>Sun, 08 Nov 2020 13:08:08 GMT</pubDate>
            <atom:updated>2020-11-08T13:15:46.922Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FT0HkcCf3k9dQJUj.jpeg" /></figure><p>Há pouco mais de um ano publiquei aqui um artigo mostrando como instalar um cluster Kubernetes no CentOS7.</p><p>De lá para cá, muita coisa mudou e a instalação e configuração do Kubernetes se tornou um processo mais fácil.</p><p>Este artigo, então, é uma espécie de atualização do <a href="https://medium.com/@gustavo.leitao/instalando-configurando-cluster-kubernetes-no-centos-7-8d81ff3f8b6a?source=your_stories_page---------------------------"><strong>primeiro</strong></a> artigo trazendo agora a versão 1.18 do Kubernetes no CentOS 8. Preparados? Vamos lá!</p><h3><strong>Cenário</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/592/1*gD_cyLTxnc51kaI-kWKZ8Q.png" /></figure><p>Para o nosso caso, vamos instalar o Kubernetes em quatro servidores. Um deles fará o papel de master e outros três o papel de workers.</p><p>No Kubernetes o nó master é responsável por executar serviços do próprio Kubernetes e garantir que o estado do cluster pemanesça estável. É o master quem verifica o estado atual e realiza o agendamento dos containers para execução nos workers.</p><p>Já os workers são responsáveis por executar os pods dos usuário. É no worker onde os famosos pods habitam.</p><p>Vamos agora ver os passos necessários a serem executados em todos os servidores. Vamos lá!</p><h3>Configurações iniciais</h3><p>Estas configurações deverão ser realizadas em todos os hots, seja ele master ou worker e visa preparar tudo para a instalação do Kubernetes.</p><p>Para iniciar, tome nota do <em>hostname</em> de cada máquina do cluster. Caso não saiba os nomes das máquinas você pode utilizar o seguinte comando para descobrir:</p><pre>$ hostname</pre><p>Em cada um dos nós, edite o arquivo /etc/hosts e configure os ips de cada uns dos hosts.</p><pre>$ sudo vi /etc/hosts</pre><p>No meu caso, o arquivo /etc/hosts ficou assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*d4-lAu_d0iCKljA85dJdMA.png" /></figure><p>Desabilite o SELinux do CentOS.</p><pre>$ sudo setenforce 0<br>$ sudo sed -i &quot;s/^SELINUX=enforcing/SELINUX=disabled/g&quot; /etc/selinux/config</pre><p>Configure o firewall para permitir livre comunicação do Kubernetes.</p><pre>$ sudo firewall-cmd --permanent --add-port=6443/tcp<br>$ sudo firewall-cmd --permanent --add-port=2379-2380/tcp<br>$ sudo firewall-cmd --permanent --add-port=10250/tcp<br>$ sudo firewall-cmd --permanent --add-port=10251/tcp<br>$ sudo firewall-cmd --permanent --add-port=10252/tcp<br>$ sudo firewall-cmd --permanent --add-port=10255/tcp<br>$ sudo firewall-cmd --reload<br>$ sudo modprobe br_netfilter<br>$ sudo su <br>$ echo &#39;1&#39; &gt; /proc/sys/net/bridge/bridge-nf-call-iptables<br>$ exit</pre><p>O Kubernetes não gosta muito do Swap. Por isso, desabilite-o em todos os nós:</p><pre>$ sudo swapoff -a</pre><p>Para que o Swap não seja habilitado automaticamente no reinicio, edite o arquico /etc/fstab executando o seguinte comando:</p><pre>$ sudo sed -i &#39;s/.*swap.*/#&amp;/&#39; /etc/fstab</pre><h3>Instalando o Docker</h3><p>Após realizadas as configurações inicias, é necessario instalar o Docker nos hosts.</p><p>Para isso, execute os seguintes comandos (em todos os hosts):</p><pre>$ sudo dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo<br>$ sudo dnf -y install https://download.docker.com/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm<br>$ sudo dnf install -y docker-ce<br>$ sudo systemctl enable docker<br>$ sudo systemctl start docker<br>$ sudo usermod -aG docker $USER</pre><p>Após essa etapa é necessário <strong>sair</strong> e <strong>logar novament</strong>e com o usuário para que as configurações ao usuário sejam aplicadas.</p><p>Para testar o pleno funcionamento do Docker execute o seguinte comando:</p><pre>$ docker run hello-world</pre><p>Se tudo ocorrer bem, a imagem do hello-world deverá ser baixada e executada no host. A figura abaixo mostra o resultado esperado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*0PSGeUzV26X7BZFsRdXVuQ.png" /></figure><h3>Instalação do Kuberenetes</h3><p>Com o Docker instalado e todas configurações prontas, é hora de finalmente instalar o Kubernetes. Esses passos devem também serem realizados em todos os nós.</p><p>Para isso, é necessário primeiro configurar o repositório do Kubernetes. Para isso, execute:</p><pre>$ sudo su<br>$ cat &lt;&lt;EOF &gt; /etc/yum.repos.d/kubernetes.repo<br>[kubernetes]<br>name=Kubernetes<br>baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64<br>enabled=1<br>gpgcheck=1<br>repo_gpgcheck=1<br>gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg<br>EOF<br>$ exit</pre><p>Em seguida, realize a instalação:</p><pre>$ sudo dnf install kubeadm-1.18.6 -y<br>$ sudo systemctl enable kubelet<br>$ sudo systemctl start kubelet</pre><p>Estamos quase lá, precisamos agora configurar o control-pane do Kubernetes que deve ser feito apenas no nó master.</p><h3>Configurando o master</h3><p>Esses passos devem ser executados apenas o nó master, para criar o painel de controle do cluster.</p><p>Inicie o cluster:</p><pre>$ sudo kubeadm init</pre><p>Uma mensagem como a se segue deve aparecer:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*IiF3WXg_ZsdGUu6R7oV4Mg.png" /></figure><p>Tome nota do comando destacado de vermelho. Ele será utilizado logo a seguir!</p><p>O próximo passo deve ser executado no seu usuário comum. Perceba que em todo procedimento utilizamos sudo para elevar as permissões. Se você utilizou o atalho de logar diretamente com o root, agora é a hora de voltar ao seu usuário. Feito isso, execute os seguintes comandos:</p><pre>$ mkdir -p $HOME/.kube<br>$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config<br>$ sudo chown $(id -u):$(id -g) $HOME/.kube/config</pre><p>Confirme que tudo está funcionando com o seguinte comando:</p><pre>$ kubectl get nodes</pre><p>Neste momento, é normal o host retornar como “NotReady”. Isso ocorre por que precisamos instalar e configurar a rede do Kubernetes. Existem vários tipos de redes suportadas pelo Kubernetes. Neste tutorial, utilizaremos a rede <a href="https://www.weave.works/">Weave</a>.</p><p>Aqui vale um pequeno comentário: Em vez de utilizar o comando padrão do weave (que muda a cada nova versão), preferi baixar o yaml da versão testada e disponibilizar no meu repositório.</p><p>Isso é particularmente importante, pois é uma forma de garantir que o procedimento funcione em qualquer momento do tempo. Outro detalhe: foi necessário fazer um ajuste, conforme reportado <a href="https://github.com/weaveworks/weave/issues/3816">nesta issue</a>.</p><p>Então, para iniciar, execute o seguinte comando:</p><pre>$ git clone <a href="https://github.com/gustavoleitao/kubernetes-weaves.git">https://github.com/gustavoleitao/kubernetes-weaves.git</a><br>$ kubectl apply -f kubernetes-weaves/weave-2.6.5.yaml</pre><p>Se preferir utilizar a última versão do Weave, execute o seguinte comando, conforme <a href="https://www.weave.works/docs/net/latest/kubernetes/kube-addon/">documentação</a>:</p><pre>kubectl apply -f &quot;https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d &#39;\n&#39;)&quot;</pre><p>Espere alguns segundos (ou 1 minuto) e digite nomamente o seguinte comando:</p><pre>$ kubectl get nodes</pre><p>Decorrido um tempinho, o nó master deve passar para o estado de <strong>Ready</strong>.</p><p>Estando tudo certo no nó master, vamos agora adicionar os demais nós workers no cluster:</p><h3><strong>Nos nós workers</strong></h3><p>Lembra do comando de join que destacamos em vermelho quando iniciamos o cluster?</p><p>Precisamos executá-lo em cada worker para que o worker possa ingressar no cluster.</p><p><strong>No meu caso</strong>, o seguinte comando foi gerado:</p><pre>sudo kubeadm join 10.3.224.209:6443 --token lhxbs4.i8qxsph897aqjyt2 --discovery-token-ca-cert-hash sha256:55d28ceb976611d80a1f4630e30e6981ee00a385a65d5830ec3866c5bc14a89f</pre><p>Para ter certeza que o nó entrou no cluster <strong>volte ao nó master</strong> e execute o seguinte comando:</p><pre>$ kubectl get nodes</pre><p>Este comando mostrará os nós disponíveis no cluster. Ao final, o resultado esperado é o seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/1*qKgqJBliiv6oVif6u-FeGw.png" /></figure><p>Caso não tenha tomado nota do comando de join, ou por acaso ele tenha expirado, você pode gerar um novo comando de join, executando o seguinte comando no master:</p><pre>kubeadm token create --print-join-command</pre><p>Bem gente, é isso! Espero que consigam configurar o <em>cluster</em> de vocês. É um pouco trabalhoso, mas se seguir direitinho todos os passos dará certo. Abraços e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53cbd29659d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Criando um cluster MongoDB com ReplicaSet e Sharding com Docker]]></title>
            <link>https://gustavo-leitao.medium.com/criando-um-cluster-mongodb-com-replicaset-e-sharding-com-docker-9cb19d456b56?source=rss-409b4784a255------2</link>
            <guid isPermaLink="false">https://medium.com/p/9cb19d456b56</guid>
            <category><![CDATA[high-availability]]></category>
            <category><![CDATA[clustering]]></category>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[sharding]]></category>
            <dc:creator><![CDATA[Gustavo Leitão]]></dc:creator>
            <pubDate>Wed, 06 Nov 2019 02:07:58 GMT</pubDate>
            <atom:updated>2019-11-06T12:49:05.364Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jto80hj5dPaQvdXTp_HWvA.png" /></figure><p>O <a href="https://www.mongodb.com/">MongoDb</a> certamente é um banco NoSQL muito popular e poderoso. Uma de suas grandes vantagens é estar preparado para escalar horizontalmente através do conceito de replicas (ReplicaSet) e particionamento dos dados (Shards).</p><p>Esse artigo tem o objetivo de criar um tutorial para que você possa criar o seu primeiro cluster do <a href="https://www.mongodb.com/">MongoDb</a> com auxílio do <a href="https://www.docker.com/">Docker</a>. Por simplificação, todos os containers serão instanciados em uma mesma máquina e, por isso, <strong>não é recomendado utilizar para fins de produção!</strong></p><p>Vamos lá?</p><p>Para a criação de um cluster mongo replicante e particionado precisamos de de três tipos diferentes de serviços, são eles:</p><ul><li><strong>Roteadores:</strong> responsáveis por receberem as requisições de leitura e escrita e redirecionar para a partição correta.</li><li><strong>Config Servers:</strong> armazenam os metadados das partições (<em>shards</em>). Os metadados incluem a lista de <a href="https://docs.mongodb.com/manual/core/sharding-data-partitioning/"><em>chunks</em></a> de cada <em>shard</em> e os intervalos que definem os <a href="https://docs.mongodb.com/manual/core/sharding-data-partitioning/"><em>chunks</em></a>.</li><li><strong>Shards:</strong> são os nós responsáveis pelo armazenamento dos dados. Cada <em>shard</em> fica responsável por um subconjunto dos dados do banco.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*Ww5_lOSzhaniV3H5GP6QSQ.png" /><figcaption>Tipos de serviços do MongoDb</figcaption></figure><p>Para o nosso caso, vamos criar um cluster com três nós replicantes de configuração (ConfigServer), três <em>shards</em> cada um como uma réplica (totalizando seis nós) e um roteador. A figura abaixo mostra a arquitetura do cluster a ser criado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/586/1*PjKoe378CdqLgQm-IHDXgQ.png" /><figcaption>Arquitetura do cluster a ser criado</figcaption></figure><p>Agora que já sabemos os serviços que serão criados, vamos ao procedimento!</p><h3>Procedimento</h3><p>Inicialmente vamos criar uma rede para a comunicação entre os containers. Para isso, execute o seguinte comando:</p><pre>$ docker network create mongo-shard</pre><h4>Servidores de Configuração (ConfigServers)</h4><p>Feito isso, vamos agora criar os containers ConfigServers. Para isso, vamos usar a imagem do mongo em seguida executar o comando para iniciar um configServer.</p><pre>$ docker run --name mongo-config01 --net mongo-shard -d mongo mongod --configsvr --replSet configserver --port 27017</pre><pre>$ docker run --name mongo-config02 --net mongo-shard -d mongo mongod --configsvr --replSet configserver --port 27017</pre><pre>$ docker run --name mongo-config03 --net mongo-shard -d mongo mongod --configsvr --replSet configserver --port 27017</pre><p>Após a iniciação dos containers do ConfigServer, é hora de configurá-los. Para isso, acesse o shell do mongo de um dos containers dos ConfigServes através do seguinte comando.</p><pre>$ docker exec -it mongo-config01 mongo</pre><p>Em seguida execute o seguinte comando para iniciar a operação dos servidores de configuração:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a13b2163876bd1f82f3b12430cd93e17/href">https://medium.com/media/a13b2163876bd1f82f3b12430cd93e17/href</a></iframe><p>Agora que os servidores de configuração já estão criados e configurados, vamos criar os S<em>hards</em>.</p><h4>Shards</h4><p>Conforme combinado, vamos criar três <em>shards</em> em que cada um possui uma replica, totalizando assim seis nós. Para isso, vamos utilizar a imagem do mongo com comando para iniciar em modo <em>shard</em>.</p><p><strong>Shard 01</strong></p><pre>$ docker run --name mongo-shard1a --net mongo-shard -d mongo mongod --port 27018 --shardsvr --replSet shard01</pre><pre>$ docker run --name mongo-shard1b --net mongo-shard -d mongo mongod --port 27018 --shardsvr --replSet shard01</pre><p><strong>Shard 02</strong></p><pre>$ docker run --name mongo-shard2a --net mongo-shard -d mongo mongod --port 27019 --shardsvr --replSet shard02</pre><pre>$ docker run --name mongo-shard2b --net mongo-shard -d mongo mongod --port 27019 --shardsvr --replSet shard02</pre><p><strong>Shard 03</strong></p><pre>$ docker run --name mongo-shard3a --net mongo-shard -d mongo mongod --port 27020 --shardsvr --replSet shard03</pre><pre>$ docker run --name mongo-shard3b --net mongo-shard -d mongo mongod --port 27020 --shardsvr --replSet shard03</pre><p>Uma vez que os <em>containers</em> já estão criados e online, precisamos configurar e iniciar os <em>shards</em>. Para isso, vamos acessar o shell de cada um dos <em>shards</em> (shard01, shard2 e shard3) aplicando sua respectiva configuração.</p><pre>$ docker exec -it mongo-shard1a mongo --port 27018</pre><p>Após acessar o shell do shard01, execute o seguinte comando de inicialização:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f15f3d54d6e484dcd6646654d31d4d04/href">https://medium.com/media/f15f3d54d6e484dcd6646654d31d4d04/href</a></iframe><p>Repita o procedimento para o shard02 e shard03, tomando cuidado para ajustar os endereços dos respectivos <em>hosts</em>.</p><pre>$ docker exec -it mongo-shard2a mongo --port 27019</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/19528cc1440093fb1ae626457075323a/href">https://medium.com/media/19528cc1440093fb1ae626457075323a/href</a></iframe><pre>$ docker exec -it mongo-shard3a mongo --port 27020</pre><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/02b0ca12d2716052a39dbdc8a8769db6/href">https://medium.com/media/02b0ca12d2716052a39dbdc8a8769db6/href</a></iframe><p>Feito isso, estamos quase prontos. Agora só falta subir o roteador para que os <em>shards</em> fiquem acessíveis.</p><h4>Roteador</h4><p>Para iniciar o serviço do roteador, iremos também usar a imagem do mongo com o comando de configuração do modo roteador (mongos).</p><pre>$ docker run -p 27017:27017 --name mongo-router --net mongo-shard -d mongo mongos --port 27017 --configdb configserver/mongo-config01:27017,mongo-config02:27017,mongo-config03:27017 --bind_ip_all</pre><p>Feito isso, todos os serviços já devem estar estar <em>online. </em>Você pode checar se todos os serviços estão operacionais através do seguinte comando:</p><pre>$ docker ps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-xqkfcBqYpp13-bShM7dQ.png" /><figcaption>Containers após criação de todos serviços</figcaption></figure><p>Por fim, precisamos configurar o roteador para que ele conheça os <em>shards</em> disponíveis. Isso pode ser feito através dos seguintes comandos:</p><pre>$ docker exec -it mongo-router mongo<br>$ sh.addShard(&quot;shard01/mongo-shard1a:27018&quot;)<br>$ sh.addShard(&quot;shard01/mongo-shard1b:27018&quot;) <br>$ sh.addShard(&quot;shard02/mongo-shard2a:27019&quot;)<br>$ sh.addShard(&quot;shard02/mongo-shard2b:27019&quot;) <br>$ sh.addShard(&quot;shard03/mongo-shard3a:27020&quot;)<br>$ sh.addShard(&quot;shard03/mongo-shard3b:27020&quot;)</pre><p>Feito isso, seu cluster já está prontinho! Para verificar seu funcionamento execute o seguinte comando:</p><pre>sh.status()</pre><p>Se tudo ocorreu bem você deverá ter um resultado semelhante a imagem seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/899/1*mqrDA3-f185sbsMuT3zhOQ.png" /></figure><p>Agora é só começar a usar o <em>cluster</em> conectando sua aplicação ao roteador e enviar os comandos de leitura e escrita.</p><p>Experimente seu <em>cluster</em> simulando a indisponibilidade de algum serviço e veja como ele se comporta.</p><p>Bem, é isso! Espero que consigam configurar o <em>cluster</em> de vocês. Abraços e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9cb19d456b56" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Criando um cluster com Redis com Docker]]></title>
            <link>https://gustavo-leitao.medium.com/criando-um-cluster-com-redis-com-docker-9e2a1bc78d84?source=rss-409b4784a255------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e2a1bc78d84</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[redis]]></category>
            <category><![CDATA[redis-cluster]]></category>
            <category><![CDATA[cluster]]></category>
            <dc:creator><![CDATA[Gustavo Leitão]]></dc:creator>
            <pubDate>Sun, 25 Aug 2019 18:56:00 GMT</pubDate>
            <atom:updated>2021-02-18T13:24:02.584Z</atom:updated>
            <content:encoded><![CDATA[<h3>Criando um cluster Redis com Docker</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6ExfIbUIiRgsKoE1zjHQxQ.jpeg" /></figure><p>Se você já teve a oportunidade de usar o Redis, conhece um pouco de Docker, mas ainda não criou um cluster Redis, este artigo foi escrito pensando em você.</p><p>No Redis, os dados são armazenados preferencialmente em memória para manter seu principal benefício: simplicidade e velocidade. Com isso, a quantidade de memória disponível na máquina acaba sendo um limitante a medida que a necessidade por armazenamento cresce.</p><p>Pensando nisso, o Redis permite aumentar a capacidade de armazenamento criando um cluster em que os dados são distribuídos entre os nós.</p><p>Além de aumentar a capacidade de armazenamento, o cluster do Redis permite também melhorar a robustez do banco, uma vez que é possível criar replicas dos dados.</p><p>No Redis cada nó pode assumir duas diferentes funções: <strong><em>master</em></strong> ou <strong><em>slave</em></strong>.</p><p>Os nós master ficam responsáveis por gerenciar um subconjunto dos dados. Cada porção de dado é chamado de <em>hash slot </em>e o Redis é capaz de lidar com até 16.384 <em>slots</em>.</p><p>De outra maneira, cada master fica responsável por armazenar um subconjunto de chaves. Quando um novo dado é solicitado para ser armazenado, primeiramente o Redis identifica qual <em>slot</em> deve ser armazenado(através da operação de módulo por 16.384 do hash da chave). Em seguida o dado é redirecionado para o nó responsável.</p><p>Os nós escravos têm a função de guardar replica de dados de um nó master. Preferencialmente cada master deve ter um ou mais réplicas.</p><p>Mas chega de teoria e vamos à prática.</p><h3>Cenário</h3><p>O cluster que funciona como esperado, deve possuir pelo menos três nó master. Isso por que em caso de segregação da rede, é realizado uma espécie de eleição de novo master e precisa-se obter uma maioria neste momento.</p><p>Para o nosso cenário, vamos criar um cluster com três master com uma réplica cada. Ou seja, três master e três nós slaves.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/345/1*r_NtudEKjlKEfZOir592XA.png" /><figcaption>Cluster com três master e três slaves.</figcaption></figure><p>Esse artigo assume que você já tem o Docker instalado e possui conhecimento de seus comandos básicos. Então, siga os seguintes passos:</p><h3>Procedimento</h3><p>Crie uma rede de nome red_cluster para comunicação entre os containers do Redis, para isso execute:</p><pre>$ docker network create red_cluster</pre><p>Vamos agora criar seis diretórios que conterão os arquivos de configuração de cada nó.</p><pre>$ mkdir node1 &amp;&amp; mkdir node2 &amp;&amp; mkdir node3 &amp;&amp; mkdir node4 &amp;&amp; mkdir node5 &amp;&amp; mkdir node6</pre><p>Vamos criar o arquivo de configuração chamado <strong>cluster-config.conf </strong>para<strong> </strong>cada nó, para isso execute:</p><pre>$ cat &gt; node1/cluster-config.conf &lt;&lt;EOF<br>port 7001<br>cluster-enabled yes<br>cluster-config-file nodes.conf<br>cluster-node-timeout 5000<br>appendonly yes<br>EOF</pre><pre>$ cat &gt; node2/cluster-config.conf &lt;&lt;EOF<br>port 7002<br>cluster-enabled yes<br>cluster-config-file nodes.conf<br>cluster-node-timeout 5000<br>appendonly yes<br>EOF</pre><pre>$ cat &gt; node3/cluster-config.conf &lt;&lt;EOF<br>port 7003<br>cluster-enabled yes<br>cluster-config-file nodes.conf<br>cluster-node-timeout 5000<br>appendonly yes<br>EOF</pre><pre>$ cat &gt; node4/cluster-config.conf &lt;&lt;EOF<br>port 7004<br>cluster-enabled yes<br>cluster-config-file nodes.conf<br>cluster-node-timeout 5000<br>appendonly yes<br>EOF</pre><pre>$ cat &gt; node5/cluster-config.conf &lt;&lt;EOF<br>port 7005<br>cluster-enabled yes<br>cluster-config-file nodes.conf<br>cluster-node-timeout 5000<br>appendonly yes<br>EOF</pre><pre>$ cat &gt; node6/cluster-config.conf &lt;&lt;EOF<br>port 7006<br>cluster-enabled yes<br>cluster-config-file nodes.conf<br>cluster-node-timeout 5000<br>appendonly yes<br>EOF</pre><p>Perceba que cada nó foi alocado uma porta diferente , que o parâmetro cluster-enabled foi setado para <strong>yes</strong> e <strong>timeout node</strong> de 5000 ms. Para mais detalhes sobre estes parâmetros acesse a documentação do Redis clicando <a href="https://redis.io/topics/cluster-tutorial">aqui</a>.</p><p>Vamos agora subir os containers tendo o cuidado de referenciar o arquivo de configuração corretamente, no meu caso:</p><pre>$ docker run -d -v \<br>$PWD/node1/cluster-config.conf:/usr/local/etc/redis/redis.conf \<br>--name redis-1 -p 7001:7001 --net red_cluster \<br>redis redis-server /usr/local/etc/redis/redis.conf</pre><pre>$ docker run -d -v \<br>$PWD/node2/cluster-config.conf:/usr/local/etc/redis/redis.conf \<br>--name redis-2 -p 7002:7002 --net red_cluster \<br>redis redis-server /usr/local/etc/redis/redis.conf</pre><pre>$ docker run -d -v \<br>$PWD/node3/cluster-config.conf:/usr/local/etc/redis/redis.conf \<br>--name redis-3 -p 7003:7003 --net red_cluster \<br>redis redis-server /usr/local/etc/redis/redis.conf</pre><pre>$ docker run -d -v \<br>$PWD/node4/cluster-config.conf:/usr/local/etc/redis/redis.conf \<br>--name redis-4 -p 7004:7004 --net red_cluster \<br>redis redis-server /usr/local/etc/redis/redis.conf</pre><pre>$ docker run -d -v \<br>$PWD/node5/cluster-config.conf:/usr/local/etc/redis/redis.conf \<br>--name redis-5 -p 7005:7005 --net red_cluster \<br>redis redis-server /usr/local/etc/redis/redis.conf</pre><pre>$ docker run -d -v \<br>$PWD/node6/cluster-config.conf:/usr/local/etc/redis/redis.conf \<br>--name redis-6 -p 7006:7006 --net red_cluster \<br>redis redis-server /usr/local/etc/redis/redis.conf</pre><blockquote>Você não precisa mapear porta se seu programa também for rodar em container. Para fins didáticos, estamos mapeando as portas para facilitar acesso externo.</blockquote><p>Após executar o docker run, os containers irão iniciar. Execute o comando docker ps para verificar se todos containers subiram, como esperado.</p><pre>$ docker ps</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Om0HwaknUq5mFmnhAFfkBQ.png" /><figcaption>Containers do redis em execução.</figcaption></figure><p>Perceba que os containers foram nomeados de redis-1 até redis-6. Cheque o IP dos containers com o seguinte comando:</p><pre>$ docker inspect -f &#39;{{ (index .NetworkSettings.Networks &quot;red_cluster&quot;).IPAddress }}&#39; redis-1 redis-2 redis-3 redis-4 redis-5 redis-6</pre><p>No meu caso, o seguinte resultado foi retornado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sjezd1Jog5VDrOfH8ENh0A.png" /><figcaption>Checando os endereços IP dos containers do Redis.</figcaption></figure><p>De posse dos endereços IP, é hora de finalmente iniciar o cluster. Para isso execute o seguinte comando <strong>tomando cuidado para alterar os endereços para os valores retornado no comando anterior</strong>:</p><pre>$ docker run -i --rm --net red_cluster redis redis-cli --cluster create 172.19.0.2:7001 172.19.0.3:7002 172.19.0.4:7003 172.19.0.5:7004 172.19.0.6:7005 172.19.0.7:7006 --cluster-replicas 1</pre><p>Perceba que ao iniciar o cluster escolhemos o parâmetro cluster-replicas = 1. Isso fará com que cada nó master tenha exatamente uma réplica.</p><p>Após isso, seu cluster está pronto. Para checar se tudo subiu como esperado, execute o seguinte comando:</p><pre>$ docker exec -it redis-1 redis-cli -p 7001 cluster nodes</pre><p>Esse comando irá acessar o nó redis-1 e executar o comando &quot;cluster nodes&quot; para verificar se todo o nós subiram.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nEJo_GcsMj1VhNDWAllCnQ.png" /></figure><p>Se o comando retornar seis nós com três <em>master</em> e três <em>slaves</em> é sinal que tudo deu certo e você já pode usar seu novo cluster normalmente!</p><p>Bem, é isso! Espero que consigam configurar o <em>cluster</em> de vocês. Abraços e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e2a1bc78d84" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Instalando e configurando um cluster Kubernetes 1.15 no CentOS 7]]></title>
            <link>https://gustavo-leitao.medium.com/instalando-configurando-cluster-kubernetes-no-centos-7-8d81ff3f8b6a?source=rss-409b4784a255------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d81ff3f8b6a</guid>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[centos7]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[centos]]></category>
            <dc:creator><![CDATA[Gustavo Leitão]]></dc:creator>
            <pubDate>Mon, 28 May 2018 12:48:16 GMT</pubDate>
            <atom:updated>2020-08-08T21:12:06.567Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rtB5jWkgvuRaclsy7UfTLA.jpeg" /></figure><p>Se você já tem familiaridade com <em>containers</em> <a href="https://www.docker.com/">Docker</a>, provavelmente já precisou manipular o ciclo de vida destes <em>containers</em> em conjunto.</p><p>Uma solução comum é utilizar o <a href="http://Docker Compose | Docker Documentation">docker-compose</a>, que permite a criação de um arquivo que descreve como os <em>containers</em> se relacionam. Assim, o docker-compose cuida de subir todos os <em>containers,</em> bem como mantê-los funcionais.</p><p>No entanto, quando precisamos orquestrar algo mais complexo que, por exemplo, execute os <em>containers</em> em diferentes hosts, o <em>docker-compose</em> não pode nos ajudar muito.</p><p>Para isso, existe uma ferramenta, desenvolvida pelo Google, que tem ganhado bastante espaço na comunidade: o <a href="https://kubernetes.io/">Kubernetes</a>. O Kubernetes é um poderoso orquestrador de <em>containers</em> que permite abstrair dos usuários toda complexidade de gerenciar múltiplos <em>containers</em> e mantê-los online.</p><p>O Kubernetes é um sistema distribuído e, por isso, roda em um <em>cluster</em> onde os <em>hosts</em> ficam disponíveis para executar os <em>containers</em>. Ou seja, o Kubernetes realiza todo o gerenciamento dos <em>containers</em> realizando o melhor esforço para mantê-los operacionais. Caso haja alguma perturbação no cenário, o Kubernetes se encarrega de realizar as operações necessárias de forma a manter a aplicação <em>online</em>.</p><p>Normalmente, o Kubernetes é utilizado junto com um serviço de cloud. O Google Cloud Platform, AWS e Azure são exemplos de serviços de cloud compatíveis com Kubernetes. No entanto, se você deseja instalar o Kubernetes do zero em um <em>cluster</em> próprio, este artigo foi escrito pensando em você!</p><h3>Cenário</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cZpvU-uTfF_ijQ9uIHfktg.jpeg" /></figure><p>Para o nosso caso, vamos instalar o Kubernetes em três hosts, como mostra o diagrama acima. Todos os hosts já estão com CentOS 7 instalado. Um deles funcionará como o <strong>master</strong> e os outros dois como <em>slaves</em>. O nó master tem a função de realizar toda orquestração dos <em>containers</em> e os <em>slaves</em> são os hosts onde os <em>containers</em> serão, de fato, executados.</p><p>Chega de papo, vamos lá!</p><h3>Configurações iniciais</h3><p>Estas configurações deverão ser realizadas em todas os <em>hosts</em> que comporão o cluster, ou seja, tanto o nó master como os escravos.</p><p>Para iniciar, tome nota do <em>hostname</em> de cada máquina do cluster. Caso não saiba os nomes das máquinas você pode utilizar o seguinte comando para descobrir:</p><pre>$ hostname</pre><p>Essa informação será importante em toda configuração. No meu caso, tenho os seguintes <strong>hostnames</strong>:</p><ul><li>Master: kubernetes-master</li><li>Node1: kubernetes-node-1.novalocal</li><li>Node2: kubernetes-node-2.novalocal</li></ul><p>Em cada um dos nós, edite o arquivo /etc/hosts e configure os ips de cada uns dos hosts.</p><pre>$ sudo vi /etc/hosts</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hrbgRCXDbeQLfFGdWFAG_A.png" /></figure><p>Os comandos a seguir devem ser executados como root.</p><p>Desabilite o SELinux do CentOS.</p><pre>$ setenforce 0<br>$ sed -i &quot;s/^SELINUX=enforcing/SELINUX=disabled/g&quot; /etc/selinux/config</pre><p>Desabilte o Firewall</p><pre>$ systemctl stop firewalld</pre><pre>$ systemctl disable firewalld</pre><p>Desabilite o Swap</p><pre>$ swapoff -a</pre><pre>$ sed -i &#39;s/.*swap.*/#&amp;/&#39; /etc/fstab</pre><p>Execute o comando a seguir para corrigir possíveis falhas de roteamento.</p><pre>$ echo &quot;1&quot; &gt; /proc/sys/net/ipv4/ip_forward</pre><pre>$ cat &gt; /etc/sysctl.d/k8s.conf &lt;&lt;EOF<br>net.bridge.bridge-nf-call-ip6tables = 1<br>net.bridge.bridge-nf-call-iptables = 1<br>EOF</pre><p>Execute o comando abaixo para aplicar as configurações.</p><pre>$ sysctl --system</pre><p>Configure os repositorios do yum</p><pre>$ yum install -y wget</pre><pre>$ mkdir /etc/yum.repos.d/bak &amp;&amp; mv /etc/yum.repos.d/*.repo /etc/yum.repos.d/bak</pre><pre>$ wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.cloud.tencent.com/repo/centos7_base.repo</pre><pre>$ wget -O /etc/yum.repos.d/epel.repo http://mirrors.cloud.tencent.com/repo/epel-7.repo</pre><pre>$ yum clean all &amp;&amp; yum makecache</pre><p>Adicione o repositório do Kubernetes no gerenciador de pacotes Yum.</p><pre>$ cat &lt;&lt;EOF &gt; /etc/yum.repos.d/kubernetes.repo</pre><pre>[kubernetes]</pre><pre>name=Kubernetes</pre><pre>baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/</pre><pre>enabled=1</pre><pre>gpgcheck=1</pre><pre>repo_gpgcheck=1</pre><pre>gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg</pre><pre>EOF</pre><p>Reinicie os hosts para aplicar as alterações, executando o seguinte comando:</p><pre>$ sudo init 6</pre><h3>Instalando o Docker</h3><p>O Docker é um pré-requisito para a instalação e funcionamento do Kubernetes. Sendo assim, instale o Docker em cada um dos hosts.</p><p>Para iniciar a instalação do Docker, primeiramente configure o repositório do yum.</p><pre>$ wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo</pre><p>Em seguida instale o pacote yum-utils executando o seguinte comando:</p><pre>$ sudo yum install -y yum-utils \<br>  device-mapper-persistent-data \<br>  lvm2</pre><pre>$ yum install pigz</pre><p>Execute o seguinte comando para instalar o docker:</p><pre>$ sudo yum install -y docker-ce-18.06.1.ce-3.el7</pre><p>Habilite e inicie o Docker.</p><pre>$ sudo systemctl enable docker &amp;&amp; systemctl start docker</pre><p>Adicione o seu usuário no grupo do Docker para garantir que possa usar os comandos Docker sem necessidade de sudo. Para isso, logue com seu usuário e execute o seguinte comando:</p><pre>$ sudo groupadd docker<br>$ sudo usermod -aG docker $USER</pre><p>Para que as configurações possam ter efeito, é necessário <strong>reiniciar a sessão</strong>.</p><p>Após logar novamente, cheque a versão a instalada com o seguinte comando:</p><pre>$ docker --version</pre><p>No meu caso, a versão instalada foi a 18.06.1-ce.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fmyLBanqiAtcr_VH-BvrnQ.png" /></figure><p>Para testar o pleno funcionamento do Docker execute o seguinte comando:</p><pre>$ docker run hello-world</pre><p>Se tudo ocorrer bem, a imagem do hello-world deverá ser baixada e executada no host. A figura abaixo mostra o resultado esperado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0PSGeUzV26X7BZFsRdXVuQ.png" /></figure><h3>Instalando o Kubernetes</h3><p>UFA! Agora vamos de fato iniciar a instalação do Kubernetes. Este procedimento deve ainda ser executado em cada um dos nós do cluster. Vamos lá? Para começar, então, execute o seguinte comando:</p><pre>$ sudo yum install -y kubelet kubeadm kubectl</pre><pre>$ systemctl enable kubelet</pre><h3>Configurando o master</h3><p>Agora vamos realizar a configuração do nó master do Kubernetes. Este é a única seção onde o procedimento deve ser executado apenas no nó master.</p><p>Inicie o Master com o seguinte comando tomando cuidado por trocar o IP 10.7.40.63 pelo IP do seu nó master.</p><pre>$ sudo kubeadm init --kubernetes-version=1.15.0 --apiserver-advertise-address=10.7.40.63 --service-cidr=10.1.0.0/16 --pod-network-cidr=10.244.0.0/16</pre><p>Se tudo ocorrer bem você receberá uma resposta conforme a tela a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IiF3WXg_ZsdGUu6R7oV4Mg.png" /></figure><p>Tome nota do comando destacado de vermelho. Ele será utilizado logo a seguir!</p><p>O próximo passo deve ser executado no seu usuário comum. Perceba que em todo procedimento utilizamos sudo para elevar as permissões. Se você utilizou o atalho de logar diretamente com o root, agora é a hora de voltar ao seu usuário. Feito isso, execute os seguintes comandos:</p><pre>$ mkdir -p $HOME/.kube<br>$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config<br>$ sudo chown $(id -u):$(id -g) $HOME/.kube/config</pre><p>Podemos executar o seguinte comando para verificar o pods em execução:</p><pre>$ kubectl get pods --all-namespaces</pre><p>Neste momento, o resultado deve ser como mostra a figura abaixo. Perceba que o <em>pod</em> do DNS permanece pendente. Isso ocorre por que ainda não configuramos a rede. Faremos isso na sequência.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BCgZhUbrhwIHSqAYARLE6w.png" /></figure><p>Agora vamos instalar nossa rede que será responsável pela comunicação entre os nós. Existem vários tipos de redes suportadas pelo Kubernetes. Neste tutorial, utilizaremos a rede <a href="https://kubernetes.io/docs/concepts/cluster-administration/networking/#flannel">Flannel</a>. Para iniciar, execute o seguinte comando:</p><pre>$ kubectl apply -f <a href="https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml">https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml</a></pre><p>Pode levar algum tempo até todos os <em>pods</em> estarem rodando. Espere até que os pods fiquem todos no estado de Running. Para verificar o estado execute o seguinte comando:</p><pre>$ kubectl get pods --all-namespaces</pre><p>Após o tempo de inicialização, o seguinte resultado é esperado:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4p1-_CJQxJSlYfjTHv1d7w.png" /></figure><p>Agora vamos realizar a configuração de cada nós escravos.</p><h3>Configurando os nós escravos</h3><p>Em cada nós escravo, além do processo comum descrito neste artigo, é necessário executar o comando kubeadm join para entrar no cluster. O <strong>comando exato</strong> é mostrado logo após o comando kubeadm init no nó master. Recupere o comando mostrado e execute em cada nó escravo.</p><p>Como exemplo, o meu comando foi o seguinte:</p><pre>$ sudo kubeadm join --token a2dc82.7e936a7ba007f01e 10.0.0.7:6443 --discovery-token-ca-cert-hash sha256:30aca9f9c04f829a13c925224b34c47df0a784e9ba94e132a983658a70ee2914</pre><p>Para ter certeza que o nó entrou no cluster <strong>volte ao nó master</strong> e execute o seguinte comando:</p><pre>$ kubectl get nodes</pre><p>Este comando mostrará os nós disponíveis no cluster. Ao final, o resultado esperado é o seguinte:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FQ3E1jNDRNDsYvNSGbU4xQ.png" /></figure><pre>$ kubeadm token create --print-join-command</pre><p>Bem gente, é isso! Espero que consigam configurar o <em>cluster</em> de vocês. É um pouco trabalhoso, mas se seguir direitinho todos os passos dará certo. Abraços e até a próxima!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d81ff3f8b6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>