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 |
implantação.yaml --- Versão da API: extensões/v1beta1 gentil: Implantação metadados: nome: operador de base de sofá especificação: réplicas: 1 modelo: metadados: rótulos: nome: operador de base de sofá especificação: contêineres: - nome: operador de base de sofá imagem: couchbase/k8s-operator0.8.0-beta env: - nome: MY_POD_NAMESPACE valueFrom: fieldRef: fieldPath: metadata.namespace - nome: MY_POD_NAME valueFrom: fieldRef: fieldPath: metadata.name portos: - nome: porta de prontidão containerPort: 8080 readinessProbe: httpGet: caminho: /readyz porto: porta de prontidão 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 |
segredo.yaml --- Versão da API: v1 gentil: Segredo metadados: nome: cb-example-auth tipo: Opaco dados: nome de usuário: QWRtaW5pc3RyYXRvcg== senha: 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 --- Versão da API: couchbase.database.couchbase.com/v1beta1 gentil: CouchbaseCluster metadados: nome: cb-example especificação: imagem de base: couchbase/servidor versão: enterprise-5.0.1 authSecret: cb-example-auth exposeAdminConsole: verdadeiro pausado: falso agrupamento: DataServiceMemoryQuota: 256 indexServiceMemoryQuota: 256 searchServiceMemoryQuota: 256 indexStorageSetting: memory_optimized autoFailoverTimeout: 10 baldes: - nome: padrão tipo: couchbase memoryQuota: 128 réplicas: 1 ioPrioridade: alto evictionPolicy (política de despejo): fullEviction Resolução de conflitos: seqno enableFlush: verdadeiro enableIndexReplica: falso - nome: amostra de viagem tipo: couchbase memoryQuota: 128 réplicas: 1 ioPrioridade: alto evictionPolicy (política de despejo): fullEviction Resolução de conflitos: seqno enableFlush: verdadeiro enableIndexReplica: falso servidores: - tamanho: 2 nome: all_services serviços: - dados - índice - consulta - pesquisa 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 (modificado) #https://github.com/korry8911/try-cb-python/blob/master/travel.py#L20 configuração.load_incluster_config() v1 = cliente.CoreV1Api() impressão("Localizando nós do Couchbase:") ret = v1.list_pod_for_all_namespaces(assistir=Falso) cbip = [] para i em ret.itens: impressão("%s\t%s\t%s" % (i.status.pod_ip, i.metadados.espaço de nome, i.metadados.nome)) se 'cb-example' (exemplo de cb) em i.metadados.nome: cbip.anexar(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 DE ubuntu:14.04 CORRER apto-obter atualização CORRER apto-obter instalar -y gcc g++ fazer cmake git-núcleo libevent-dev libev-dev libssl-dev libffi-dev psmisc iptables zíper descompactar python-dev python-tubulação vim enrolar # compilar libcouchbase CORRER git clone git://github.com/couchbase/libcouchbase.git && \ mkdir libcouchbase/construir WORKDIR libcouchbase/construir CORRER ../cmake/configurar --prefixo=/usr && \ fazer && \ fazer instalar WORKDIR / CORRER git clone https://github.com/korry8911/tentar-cb-python.git WORKDIR tentar-cb-python ARG FILIAL=5.0 CORRER git checkout $BRANCH CORRER gato viagens.py # install python deps CORRER pip2 instalar --atualização embalagem diretórios de aplicativos CORRER tubulação instalar -U tubulação ferramentas de configuração CORRER tubulação instalar paramiko &&\ tubulação instalar evento &&\ tubulação instalar boto &&\ tubulação instalar httplib2 &&\ tubulação instalar pyyaml &&\ tubulação instalar couchbase CORRER tubulação instalar -r requisitos.txt CÓPIA ponto de entrada.sh ponto de entrada.sh CORRER chmod +x ./ponto de entrada.sh PONTO DE ENTRADA ["sh", "entrypoint.sh"] |
|
1 2 3 4 |
#entrypoint.sh #!/bin/bash python viagens.py enquanto verdadeiro; fazer dormir 1000; feito |
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 |
amostra de viagem.yaml --- Versão da API: extensões/v1beta1 gentil: Implantação metadados: nome: amostra de viagem especificação: réplicas: 1 modelo: metadados: rótulos: nome: amostra de viagem especificação: contêineres: - nome: amostra de viagem imagem: your-dockerhub-handle/travel-sample:mais recente |
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 --- gentil: Serviço Versão da API: v1 metadados: nome: amostra de viagens especificação: tipo: NodePort portos: - porto: 8080 nodePort: 32000 seletor: nome: amostra de viagens |
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/.
