O Couchbase Autonomous Operator permite que você execute implementações do Couchbase nativamente no Kubernetes de código aberto ou na Enterprise Red Hat OpenShift Container Platform. Tenho o prazer de anunciar a disponibilidade do Couchbase Autonomous Operator 0.8 Beta Refresh hoje!
Executar e gerenciar um cluster do Couchbase ficou muito mais fácil com a introdução do Operador autônomo do Couchbase para Kubernetes. Os usuários agora podem implantar o Couchbase sobre o Kubernetes e fazer com que o Couchbase Autonomous Operator cuide de grande parte do gerenciamento do cluster, como recuperação de falhas e dimensionamento multidimensional. No entanto, os usuários podem se sentir um pouco desconfortáveis em apenas sentar e observar o Couchbase Autonomous Operator fazer seu trabalho. Para aliviar um pouco a preocupação deles, esta série de três partes do blog abordará as diferentes maneiras pelas quais a equipe de Engenharia de Qualidade aqui na Couchbase oferece tranquilidade aos nossos clientes ao executar o Couchbase no Kubernetes.
Esta série do blog destacará três tipos de testes que fazemos para o Couchbase no Kubernetes. A primeira postagem da série se concentrará em testes manuais. A segunda publicação será sobre o teste do Operador Autônomo do Couchbase. E a terceira postagem mostrará aos nossos usuários como testar as instâncias do Couchbase por conta própria com o testrunner, nosso conjunto de testes funcionais.
Fase 1: Certificação manual do operador autônomo do Couchbase
Os testes manuais costumam ser entediantes em comparação com as emoções dos testes automatizados, mas com o Kubernetes eles podem ser bem divertidos. Nesta postagem, vamos acompanhar a configuração do Aplicativo de amostra de viagem do Couchbase com um cluster Couchbase gerenciado pelo operador como armazenamento de dados, tudo no Kubernetes. Depois que o aplicativo e o cluster estiverem configurados no Kubernetes, testaremos alguns cenários de dimensionamento e falha.
Nas seções a seguir, abordaremos:
0: Pré-requisitos e configuração
1: Implantação do cluster
2: Configuração do cluster
3: Implementação de aplicativos
4: Verificação
Pré-requisitos e configuração:
Para configurar esse aplicativo de amostra de viagem usando o Couchbase no Kubernetes, usaremos o minikube. As instruções para configurar o minikube podem ser encontradas aqui: https://kubernetes.io/docs/getting-started-guides/minikube/.
Depois que o minikube estiver configurado, talvez você queira aumentar a contagem de memória e CPU. Você precisará abrir o painel do Kubernetes para monitorar o uso do cluster: painel de controle do minikube
Implantação de cluster:
Depois de configurar o minikube, precisaremos inicializar o operador autônomo do Couchbase e o cluster do Couchbase que o operador gerenciará. O arquivo YAML a seguir dirá ao Kubernetes Master para criar uma implantação do Couchbase Autonomous Operator:
|
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 |
deployment.yaml --- apiVersion: extensions/v1beta1 kind: Deployment metadata: name: couchbase-operator spec: replicas: 1 template: metadata: labels: name: couchbase-operator spec: containers: - name: couchbase-operator image: couchbase/k8s-operator:0.8.0-beta env: - name: MY_POD_NAMESPACE valueFrom: fieldRef: fieldPath: metadata.namespace - name: MY_POD_NAME valueFrom: fieldRef: fieldPath: metadata.name ports: - name: readiness-port containerPort: 8080 readinessProbe: httpGet: path: /readyz port: readiness-port initialDelaySeconds: 3 periodSeconds: 3 failureThreshold: 19 |
Crie um arquivo chamado deployment.yaml e enviar esse YAML para o Kubernetes com: kubectl create -f path/to/deployment.yaml. Após alguns segundos, a implantação do operador deverá aparecer no painel do Kubernetes.
Figura 1: Estado do cluster do Kubernetes após a implantação do Operador Autônomo do Couchbase.
Em seguida, um segredo deve ser fornecido ao Kubernetes para que o Operador Autônomo do Couchbase possa gerenciar os nós do Couchbase.
|
1 2 3 4 5 6 7 8 9 10 |
secret.yaml --- apiVersion: v1 kind: Secret metadata: name: cb-example-auth type: Opaque data: username: QWRtaW5pc3RyYXRvcg== password: cGFzc3dvcmQ= |
Crie um arquivo chamado secret.yaml e envie o segredo para o Kubernetes com o seguinte: kubectl create -f path/to/secret.yaml.
Em seguida, vamos criar um cluster de 2 nós do Couchbase. O YAML a seguir especifica um cluster com dois nós, dois buckets (default e travel-sample) e todos os serviços ativados:
|
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 46 47 |
cb-cluster.yaml --- apiVersion: couchbase.database.couchbase.com/v1beta1 kind: CouchbaseCluster metadata: name: cb-example spec: baseImage: couchbase/server version: enterprise-5.0.1 authSecret: cb-example-auth exposeAdminConsole: true paused: false cluster: dataServiceMemoryQuota: 256 indexServiceMemoryQuota: 256 searchServiceMemoryQuota: 256 indexStorageSetting: memory_optimized autoFailoverTimeout: 10 buckets: - name: default type: couchbase memoryQuota: 128 replicas: 1 ioPriority: high evictionPolicy: fullEviction conflictResolution: seqno enableFlush: true enableIndexReplica: false - name: travel-sample type: couchbase memoryQuota: 128 replicas: 1 ioPriority: high evictionPolicy: fullEviction conflictResolution: seqno enableFlush: true enableIndexReplica: false servers: - size: 2 name: all_services services: - data - index - query - search dataPath: /opt/couchbase/var/lib/couchbase/data indexPath: /opt/couchbase/var/lib/couchbase/data |
Envie a configuração do cluster com: kubectl create -f path/to/cb-cluster.yaml.
Figura 2: Estado do cluster do Kubernetes após o dimensionamento para 2 nós do Couchbase.
Configuração de cluster:
Agora que temos um cluster de dois nós gerenciado pelo Operador Autônomo do Couchbase, as atualizações na configuração do cluster devem ser feitas no arquivo cb-cluster.yaml e reenviadas ao Kubernetes. Se alguma alteração for feita manualmente por meio da interface do usuário do Couchbase, o operador tomará medidas para realinhar o cluster com a configuração especificada em cb-cluster.yaml. Para fazer alterações no cluster, primeiro faça as alterações em cb-cluster.yaml e, em seguida, atualize o Kubernetes com: kubectl apply -f path/to/cb-cluster.yaml
A próxima etapa é carregar os dados da amostra de viagem e as definições de índice no bucket de amostra de viagem do cluster. O comando a seguir chamará o cbimport no pod cb-example-0000: kubectl exec pod cb-example-0000 -ti /opt/couchbase/bin/cbimport json -c 127.0.0.1:8091 -u Administrator -p password -b travel-sample -f sample -d /opt/couchbase/samples/travel-sample.zip
Implementação de aplicativos:
O cluster já está configurado, mas o aplicativo de amostra de viagem ainda não. Agora, precisamos criar uma imagem do docker que o Kubernetes usará para o aplicativo. O dockerfile abaixo extrairá o aplicativo travel-sample do meu fork no github, https://github.com/korry8911/try-cb-python, e instalará todas as dependências. O arquivo travel.py foi modificado para esta postagem do blog para usar o cliente python do Kubernetes para obter os IPs dos nós do Couchbase em execução no mesmo namespace do Kubernetes.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#travel.py (modified) #https://github.com/korry8911/try-cb-python/blob/master/travel.py#L20 config.load_incluster_config() v1 = client.CoreV1Api() print("Finding Couchbase Nodes:") ret = v1.list_pod_for_all_namespaces(watch=False) cbip = [] for i in ret.items: print("%s\t%s\t%s" % (i.status.pod_ip, i.metadata.namespace, i.metadata.name)) if 'cb-example' in i.metadata.name: cbip.append(i.status.pod_ip) |
|
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 |
#Dockerfile FROM ubuntu:14.04 RUN apt-get update RUN apt-get install -y gcc g++ make cmake git-core libevent-dev libev-dev libssl-dev libffi-dev psmisc iptables zip unzip python-dev python-pip vim curl # build libcouchbase RUN git clone git://github.com/couchbase/libcouchbase.git && \ mkdir libcouchbase/build WORKDIR libcouchbase/build RUN ../cmake/configure --prefix=/usr && \ make && \ make install WORKDIR / RUN git clone https://github.com/korry8911/try-cb-python.git WORKDIR try-cb-python ARG BRANCH=5.0 RUN git checkout $BRANCH RUN cat travel.py # install python deps RUN pip2 install --upgrade packaging appdirs RUN pip install -U pip setuptools RUN pip install paramiko &&\ pip install gevent &&\ pip install boto &&\ pip install httplib2 &&\ pip install pyyaml &&\ pip install couchbase RUN pip install -r requirements.txt COPY entrypoint.sh entrypoint.sh RUN chmod +x ./entrypoint.sh ENTRYPOINT ["sh", "entrypoint.sh"] |
|
1 2 3 4 |
#entrypoint.sh #!/bin/bash python travel.py while true; do sleep 1000; done |
Crie a imagem do docker do aplicativo de amostra de viagem com: docker build -t your-dockerhub-handle/travel-sample:latest. A imagem do docker precisa ser carregada no nó de trabalho do Kubernetes. A maneira mais fácil de fazer isso é puxar a imagem do dockerhub. Envie a imagem de amostra de viagem com: docker push your-dockerhub-handle/travel-sample:latest.
A configuração do aplicativo travel-sample é definida no arquivo a seguir. Certifique-se de adicionar seu identificador de docker.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
travel-sample.yaml --- apiVersion: extensions/v1beta1 kind: Deployment metadata: name: travel-sample spec: replicas: 1 template: metadata: labels: name: travel-sample spec: containers: - name: travel-sample image: your-dockerhub-handle/travel-sample:latest |
Carregue o aplicativo de amostra de viagem com: kubectl create -f path/to/travel-sample.yaml.
Figura 3: Estado do cluster do Kubernetes após a implantação do aplicativo de amostra de viagem.
O Kubernetes, por padrão, não permite o acesso a pods de fora do cluster. Portanto, para acessar o aplicativo travel-sample, um serviço node-port deve ser criado para fazer proxy da porta na qual o aplicativo travel-sample escuta as solicitações recebidas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
nodeport.yaml --- kind: Service apiVersion: v1 metadata: name: travelsample spec: type: NodePort ports: - port: 8080 nodePort: 32000 selector: name: travelsample |
Crie o serviço node-port para a amostra de viagem com: kubectl create -f path/to/nodeport.yaml.
Figura 4: Estado do cluster do Kubernetes após adicionar um serviço node-port.
Como estamos executando o aplicativo no minikube, devemos acessar o aplicativo de amostra de viagem executando: Exemplo de viagens de serviço minikube.
Verificação:
Agora que já brincamos com o aplicativo de amostra de viagem, vamos aumentar o cluster do Couchbase em um nó. Para fazer isso, altere o parâmetro de tamanho na seção de servidor do arquivo cb-cluster.yaml de 2 para 3. Em seguida, envie as alterações para o Kubernetes com: kubectl apply -f path/to/cb-cluster.yaml.
Figura 5: Estado do cluster do Kubernetes após o dimensionamento para 3 nós do Couchbase.
O cluster do Couchbase agora tem 3 nós, o que é suficiente para testar o recurso de autofailover dos operadores autônomos do Couchbase. Vamos eliminar um nó do Couchbase para simular um cenário de falha e observar o Operador Autônomo do Couchbase reequilibrar automaticamente um novo nó de volta ao cluster. Elimine um pod do Couchbase navegando até Pods no painel do Kubernetes e excluindo o pod cb-example-0002.
Após o período de tempo limite do autofailover de 10 segundos, o Operador Autônomo do Couchbase ejetará o nó com falha do cluster, inicializará um novo nó e fará o rebalanceamento do nó no cluster. Durante todo esse processo, os usuários podem jogar com o aplicativo de amostra de viagem sem nenhuma interrupção de serviço
Figura 6: Estado do cluster do Kubernetes após a recuperação de uma falha no nó do Couchbase.
Conclusão:
O Couchbase Autonomous Operator elimina grande parte do incômodo de executar um cluster do Couchbase em Kubernetes de código aberto e/ou Enterprise Red Hat OpenShift Container Platform. O estado desejado do cluster é mantido automaticamente, mesmo em caso de falha do nó. A certificação manual do recurso de recuperação de nós é divertida, mas são necessários mais testes. Na próxima publicação, analisaremos em detalhes nossa abordagem de teste funcional para outros recursos do Couchbase Autonomous Operator.
Pronto para dar uma olhada no Beta?
- É fácil colocar as mãos na versão beta seguindo as etapas abaixo Pré-requisitos e configuração para implantar o Couchbase Operator na plataforma Kubernetes ou OpenShift.
- Link para o Dockerfile
- Servidor Couchbase - https://hub.docker.com/_/couchbase/
- Operador do Couchbase - https://hub.docker.com/r/couchbase/k8s-operator/
Se você tiver alguma dúvida, comentário ou feedback adicional, deixe um comentário abaixo ou publique em https://www.couchbase.com/forums/.
