Em termos simples, o kops é o kubectl para clusters de kubernetes (k8s). O poder do kubernetes é que ele elimina o aprisionamento ao fornecedor, oferece portabilidade para seus aplicativos, bancos de dados, caso seja tomada a decisão de mudar de fornecedor de nuvem ou se os fluxos de trabalho da nuvem precisarem ser transferidos para o local. Seja qual for o cenário, o kubernetes oferece essa liberdade.
Arquitetura KOPS
Com o objetivo de fazer uma divulgação completa, é mais fácil usar as ferramentas fornecidas pelos fornecedores de nuvem. Ferramentas de código aberto, como o kops, funcionam igualmente bem e são muito eficientes.
O Operador Autônomo do Couchbase estende a API do Kubernetes criando uma Definição de Recurso Personalizado (CRD) e registrando um controlador específico do Couchbase (o Operador Autônomo) para gerenciar clusters do Couchbase.
Para este blog, usaremos o AWS como IaaS e demonstraremos o uso do kops, os recursos e o Couchbase Autonomous Operator executando o cluster do Couchbase em escala.
O que o KOPS pode fazer?
"O kops ajuda você a criar, destruir, atualizar e manter clusters Kubernetes de nível de produção e altamente disponíveis a partir da linha de comando. Atualmente, o AWS (Amazon Web Services) é oficialmente suportado, com o GCE em suporte beta e o VMware vSphere em alfa, além de outras plataformas planejadas." [1]
Vamos direto ao ponto e ver como isso funciona?
- Instalar o kops
- Criar um cluster do k8s no AWS
- Configurar o painel de controle do k8s
- Verificar e validar o cluster k8s
- Implantar o operador autônomo do Couchbase no K8s
- Implantar o cluster do couchbase
- Resiliência do serviço
- Próximas etapas
Instalar o KOPS
OSX a partir do Homebrew
|
1 2 |
$ brew update $ brew install kops |
Linux
|
1 |
$ curl -LO https://github.com/kubernetes/kops/releases/download/$(curl -s https://api.github.com/repos/kubernetes/kops/releases/latest | grep tag_name | cut -d '"' -f 4)/kops-linux-amd64chmod +x kops-linux-amd64sudo mv kops-linux-amd64 /usr/local/bin/kops |
Criar um cluster do k8s no AWS
Antes de podermos usar o kops para criar o cluster do k8s, precisamos criar políticas de IAM para o kops e para que ele possa provisionar os recursos necessários para criar o cluster do k8s. Essa é uma operação única, que precisa ser feita apenas uma vez
Pré-requisitos para kops
Instalar a CLI do AWS
Para MacOS
$ pip3 instalar awscli --upgrade --user
Para outras plataformas, clique aqui
OBSERVAÇÃO: operação única
Habilite o ambiente AWS executando "aws configure" e execute os comandos abaixo
|
1 2 3 4 5 6 7 8 9 10 |
$ aws configure # enter appropriate credentials with user with perms to create user/groups $ aws iam create-group --group-name kops $ aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2FullAccess --group-name kops $ aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonRoute53FullAccess --group-name kops $ aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess --group-name kops $ aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/IAMFullAccess --group-name kops $ aws iam attach-group-policy --policy-arn arn:aws:iam::aws:policy/AmazonVPCFullAccess --group-name kops $ aws iam create-user --user-name kops $ aws iam add-user-to-group --user-name kops --group-name kops $ aws iam create-access-key --user-name kops |
Criar um bucket S3 para armazenar configuração/dados do kops
No meu caso, seu nome é rd-k8s-aws e para a região us-west-1
|
1 2 3 |
$ aws s3api create-bucket --bucket rd-k8s-aws --region us-west-1 --create-bucket-configuration LocationConstraint=us-west-1 $ aws s3api put-bucket-versioning --bucket rd-k8s-aws --versioning-configuration Status=Enabled |
Defina as variáveis de ambiente para o armazenamento de estado do kops e o nome do cluster
Escolha qualquer nome de cluster para seu cluster, eu escolhi rdc.k8s.local
|
1 2 3 |
$ export KOPS_STATE_STORE=s3://rd-k8s-aws $ export KOPS_CLUSTER_NAME=rdc.k8s.local |
Criar um cluster k8s com o kops
Escolha a região do AWS, o tamanho da instância e a contagem de nós para o cluster do k8s.
|
1 |
$ kops create cluster --node-count=7 --node-size=m4.4xlarge --zones=us-west-2a --name ${KOPS_CLUSTER_NAME} --state=${KOPS_STATE_STORE} --yes |
OBSERVAÇÃO: Leva cerca de 5 a 8 minutos, um bom momento para tomar um café!
A amostra de saída é semelhante a esta
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
$ kops validate cluster Validating cluster rdc.k8s.local INSTANCE GROUPS NAME ROLE MACHINETYPE MIN MAX SUBNETS master-us-west-1a Master m3.medium 1 1 us-west-1a nodes Node m4.4xlarge 7 7 us-west-1a NODE STATUS NAME ROLE READY ip-172-20-42-242.us-west-1.compute.internal node True ip-172-20-43-56.us-west-1.compute.internal node True ip-172-20-44-17.us-west-1.compute.internal node True ip-172-20-44-80.us-west-1.compute.internal node True ip-172-20-48-254.us-west-1.compute.internal node True ip-172-20-56-254.us-west-1.compute.internal node True ip-172-20-60-79.us-west-1.compute.internal master True ip-172-20-63-146.us-west-1.compute.internal node True Your cluster rdc.k8s.local is ready |
Obter os nós e validar o cluster k8s
|
1 2 3 |
$ kubectl get nodes --show-labels $ kubectl cluster-info |
Nesse ponto, o contexto do kubectl ou do k8s deve apontar para o cluster do AWS k8s
Configurar o painel de controle do k8s
|
1 |
$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/master/src/deploy/recommended/kubernetes-dashboard.yaml |
|
1 2 |
$ kubectl create serviceaccount dashboard -n default $ kubectl create clusterrolebinding dashboard-admin -n default --clusterrole=cluster-admin --serviceaccount=default:dashboard |
Em uma guia/terminal diferente, execute o comando abaixo para fazer proxy do servidor api do k8s no laptop local
|
1 |
$ kubectl proxy |
Obter o token para acessar o painel do k8s
|
1 |
$ kubectl get secret $(kubectl get serviceaccount dashboard -o jsonpath="{.secrets[0].name}") -o jsonpath="{.data.token}" | base64 --decode |
Escolha a opção para usar o token e, enquanto estiver pegando o token acima, pule % no final.
Faça login no painel de controle do k8s em https://127.0.0.1:8001/ui [2]
Verificar e validar o cluster k8s
Valide o cluster k8s usando o comando
|
1 |
$ kops validate cluster |
# verifique se o número de nós mencionados na criação do cluster corresponde aqui
|
1 |
$ kubectl get nodes |
Implantar o operador autônomo do Couchbase no K8s
Agora que implantamos o cluster do k8s, é hora de implantar o operador do couchbase
Primeiro, implantamos o operador, precisamos habilitar o RBAC para o operador, precisamos criar o ClusterRole para o Operador do Couchbase
|
1 |
$ kubectl create -f https://raw.githubusercontent.com/ramdhakne/blogs/master/kops/cbyaml/cluster-role.yaml |
Observação: Essa função só precisa ser criada uma vez.
Depois que o ClusterRole for criado, você precisará criar uma ServiceAccount no namespace em que está instalando o Couchbase Operator e, em seguida, atribuir o ClusterRole a essa ServiceAccount usando um Vinculação de ClusterRole. Neste guia, usaremos o padrão para criar o ServiceAccount.
|
1 2 3 |
$ kubectl create serviceaccount couchbase-operator --namespace default $ kubectl create clusterrolebinding couchbase-operator --clusterrole couchbase-operator --serviceaccount default:couchbase-operator |
Implantar o operador do couchbase
|
1 |
$ kubectl create -f https://raw.githubusercontent.com/ramdhakne/blogs/master/kops/cbyaml/operator.yaml |
A execução desse comando faz o download da imagem do Docker do Couchbase Operator especificada no arquivo operator.yaml e cria um arquivo implantação que gerencia uma única instância do Couchbase Operator. O Couchbase Operator usa uma implantação para que possa reiniciar se o pod em que está sendo executado morrer.
|
1 |
$ kubectl get deployments -l app=couchbase-operator |
Você deve continuar a sondar o status do Operador até que o resultado seja semelhante ao resultado a seguir:
|
1 2 |
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE couchbase-operator 1 1 1 1 47s |
Quando o operador do couchbase estiver instalado e funcionando, ele terá a seguinte aparência
|
1 2 3 |
$ kubectl get pods NAME READY STATUS RESTARTS AGE couchbase-operator-7676b7cf47-99b5v 1/1 Running 0 1m |
Precisamos implantar o segredo para autenticar a GUI do servidor couchbase
|
1 |
$ kubectl create -f https://raw.githubusercontent.com/ramdhakne/blogs/master/kops/cbyaml/secret.yaml |
Implante agora o cluster de 10 nós do Couchbase
|
1 |
$ kubectl create -f https://raw.githubusercontent.com/ramdhakne/blogs/master/kops/cbyaml/couchbase-cluster-multi.yaml |
Obter a listagem dos pods do couchbase
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
$ kubectl get pods NAME READY STATUS RESTARTS AGE cb-example-aws-0000 1/1 Running 0 7m cb-example-aws-0001 1/1 Running 0 6m cb-example-aws-0002 1/1 Running 0 5m cb-example-aws-0003 1/1 Running 0 4m cb-example-aws-0004 1/1 Running 0 3m cb-example-aws-0005 1/1 Running 0 2m cb-example-aws-0006 1/1 Running 0 2m cb-example-aws-0007 1/1 Running 0 1m cb-example-aws-0008 1/1 Running 0 1m cb-example-aws-0009 1/1 Running 0 50s couchbase-operator-7676b7cf47-99b5v 1/1 Running 0 17m |
Para acessar a GUI do Couchbase, acessaremos a porta 8091 e, para isso, podemos realizar o encaminhamento de porta da seguinte forma
|
1 |
$ kubectl port-forward cb-example-aws-0000 8091:8091 |
A GUI do servidor Couchbase pode ser acessada em https://localhost:8091
Resiliência do serviço
Para mostrar a resiliência do serviço, podemos eliminar um pod, simulando a perda de um nó do couchbase.
|
1 |
$ kubectl delete pod cb-example-aws-0001 |
O maior recurso que o Kubernetes nos oferece é a resiliência do serviço: se perdermos um pod, o Kubernetes verificará a definição do cluster e entenderá que ele precisa ter 3 pods e criará um novo, adicionará ao cluster e, em seguida, fará o rebalanceamento no cluster. Dessa forma, elimina-se a tarefa administrativa crucial de monitorar o cluster quanto a falhas de nós, decidir o que fazer quando isso acontecer e, em seguida, executar a operação de rebalanceamento. Tudo isso acontece de forma oculta, e os aplicativos serão executados sem interrupções.
Se listarmos os pods novamente, veremos algo parecido com isto
|
1 2 3 4 5 6 7 |
$ kubectl get pods --watch ... ... cb-example-aws-0010 0/1 Pending 0 0s cb-example-aws-0010 0/1 Pending 0 0s cb-example-aws-0010 0/1 ContainerCreating 0 0s cb-example-aws-0010 1/1 Running 0 1s |
A instalação do cbc-pillowfight para gerar a carga KV nos dá uma ideia de quais são os limites que podemos atingir nesse cluster
No servidor de aplicativo único, executando o pillowfight com os seguintes parâmetros
|
1 |
# cbc-pillowfight -U couchbase://localhost/kopsClusterBucket -u Administrator -P password -J -t 4 -I 10000 -p `hostname` |
Desempenho da KV com briga de travesseiros
Com um único servidor de aplicativos, conseguimos obter ~34K Ops/Sec
Aumentando o nível, usando outro servidor de aplicativos para executar o pillowfight, podemos obter mais desempenho na ordem de ~51k Ops/Sec
Desempenho da KV com briga de travesseiros
Conclusão
O que aprendemos aqui é que, com o uso do kops, é muito fácil implantar clusters do Couchbase em escala, e o operador autônomo oferece benefícios como resiliência de serviço, reequilíbrio automático, criação automática de buckets, fácil integração com o pipeline de CI/CD. Os arquivos yaml podem ser padronizados para Dev/QA/UAT e prod.
Referências:
[1] https://github.com/kubernetes/kops
[2] Solução de problemas do painel do k8s
