¿Por qué exponer la base de datos Couchbase en la red pública?
A continuación figuran algunos ejemplos:
-
Replicación entre centros de datos (XDCR) para alta disponibilidad y recuperación ante desastres
-
Acceso del SDK de cliente al clúster de Couchbase
-
Plataformas de base de datos como servicio (DBaaS)
*Nota - Todos estos casos de uso comparten un objetivo común; permiten a los clientes acceder a la instancia de base de datos sin tener que establecer una VPN a una instancia de Kubernetes. También requieren una comunicación segura protegida por TLS que a veces es difícil de conseguir con la arquitectura típica de Kubernetes.
¿Cómo resolvimos la creación de redes públicas mediante el DNS externo de Kubernetes?
Al desplegar aplicaciones en Kubernetes, normalmente se utilizan recursos de Kubernetes como Service e Ingress para exponer aplicaciones fuera del clúster de Kubernetes en el dominio deseado. Esto implica una gran cantidad de configuración manual de los recursos de Kubernetes y también los registros DNS en su proveedor, que puede ser un proceso largo y erróneo. Esto pronto puede convertirse en un inconveniente a medida que su aplicación crece en complejidad, y también cuando la IP externa cambia, es necesario actualizar los registros DNS en consecuencia.
Para ello, la Equipo Kubernetes sig-network creó el DNS externo para gestionar registros DNS externos de forma autónoma desde un clúster Kubernetes. Una vez desplegado, el DNS externo funciona en segundo plano y apenas requiere configuración adicional. Crea registros DNS en proveedores DNS externos a Kubernetes para que los recursos de Kubernetes sean detectables a través de los proveedores DNS externos, y le permite controlar los registros DNS dinámicamente de forma agnóstica al proveedor DNS. Siempre que descubra que se está creando o actualizando un Servicio o Ingress, el controlador DNS externo actualizará los registros al instante.
Al desplegar la base de datos Couchbase utilizando la estrategia de red pública con DNS Externo para su arquitectura de red, los nodos del clúster Couchbase se exponen utilizando servicios de balanceo de carga que tienen asignadas direcciones IP públicas. El controlador de DNS Externo se encargará entonces de gestionar el DNS dinámico (DDNS) en un proveedor basado en la nube para proporcionar un direccionamiento estable y una base para TLS.
Ahora, ¡vamos a verlo en acción!
Ahora vamos a seguir los pasos para desplegar el cluster de Couchbase usando Operador Autónomo 2.0 en EKS y acceder al cluster de Couchbase a través de una red pública que se gestiona a través de DNS Externo. A continuación se muestra una visión general de la arquitectura de nuestro despliegue.
Redes Públicas con Couchbase Autonomous Operator usando Kubernetes DNS Externo
Requisitos previos
Antes de empezar, hay algunos requisitos previos importantes.
- Instalación y configuración kubectl kubectl es una interfaz de línea de comandos para ejecutar comandos en clústeres Kubernetes.
- Instale la última CLI DE AWS - La CLI de AWS es una herramienta unificada que le permite interactuar con los servicios de AWS mediante comandos en su shell de línea de comandos. En este caso, utilizaremos la CLI de AWS para comunicarnos de forma segura con el clúster de Kubernetes que se ejecuta en AWS.
- Despliegue el clúster EKS. El sitio Grupo EKS puede desplegarse utilizando la función Consola AWS o eksctl. En este artículo, desplegaremos el clúster EKS en la plataforma us-este-1 región con 3 nodos trabajadores en tres zonas de disponibilidad como se menciona a continuación.
|
1 2 3 4 5 6 7 8 9 10 |
$ eksctl crear grupo \ --nombre cb-op2-edns \ --región us-este-1 \ --zonas us-este-1a,us-este-1b,us-este-1c \ --nodegroup-nombre eks-trabajadores \ --nodo-tipo m4.xlarge \ --nodos 3 \ --nodos-min 3 \ --nodos-max 6 \ --nodo-ami auto |
4. Necesitará un dominio DNS público. El dominio puede adquirirse en un registrador como GoDaddy, Ruta 53 de AWS, Namecheapetc. Para este artículo, estoy usando mi propio dominio registrado (GoDaddy) balajiacloud.guru y le sugiero que consiga el suyo antes de continuar.
5. Por último, necesitará un proveedor de DNS externo. Durante el ciclo de vida de un cluster Couchbase, los nodos pueden ser añadidos y eliminados para escalar el cluster, actualizaciones, o recuperación de fallos. En cada instancia, nuevos nombres DNS necesitan ser creados para cualquier nuevo pod de Couchbase que sea creado, o nombres DNS eliminados de pods que sean borrados. El proveedor DDNS expone una API REST que permite al controlador DNS externo de Kubernetes sincronizar el aspecto del clúster Couchbase con el DNS público.
Aquí está la lista de todos los documentados y conocidos DNS externo para la plataforma Kubernetes. En este artículo, utilizaremos Cloudflare como proveedor de DNS externo. Si tiene previsto utilizar Cloudflare como proveedor de DNS externo, deberá crear una cuenta de Cloudflare y añadir el dominio DNS a la cuenta.
Creación de certificados TLS
El Operador se asegura de que configures tus clusters Couchbase de forma segura. Si el Operador detecta que un clúster está siendo expuesto en la Internet pública, impondrá el cifrado TLS.
Antes de generar los certificados TLS necesitamos determinar en qué dominio DNS estará el cluster de Couchbase. Podemos usar nuestro balajiacloud.guru directamente, pero entonces sólo podrá ser utilizado por un único cluster de Couchbase. Por lo tanto usaremos un subdominio llamado cbdemo.balajiacloud.guru como espacio de nombres único para nuestro clúster. En general, un nombre DNS comodín (*.cbdemo.balajiacloud.guru) manejará todos los nombres DNS públicos generados por el Operador. Esto necesita ser añadido al certificado del cluster Couchbase.
Utilizaremos el EasyRSA para crear los certificados TLS. EasyRSA de OpenVPN hace que el funcionamiento de una infraestructura de clave pública (PKI) sea relativamente sencillo y es el método recomendado para ponerse en marcha rápidamente.
1. Vamos a crear un directorio llamado tls y clone el repositorio EasyRSA.
|
1 2 3 4 5 6 7 8 |
$ git clonar https://github.com/OpenVPN/easy-rsa Clonación en easy-rsa... remoto: Enumeración objetos: 26, hecho. remoto: Contando objetos: 100% (26/26), hecho. remoto: Comprimir objetos: 100% (20/20), hecho. remoto: Total 1979 (delta 9), reutilizado 19 (delta 6), envase-reutilizado 1953 Recepción objetos: 100% (1979/1979), 5.75 MiB | 1.92 MiB/s, hecho. Resolver deltas: 100% (859/859), hecho. |
2. Inicialice y cree el certificado/clave de la CA. Se le pedirá una contraseña de clave privada y el nombre común (CN) de la CA, algo así como Couchbase CA es suficiente. El certificado CA estará disponible como pki/ca.crt.
|
1 |
$ cd fácil-rsa/easyrsa3 |
|
1 2 3 4 |
$ ./easyrsa init-pki init-pki completa; usted mayo ahora crear a CA o solicita. Su recién creado PKI dir es: /Usuarios/balajinarayanan/k8s/couchbase/operador/tls/fácil-rsa/easyrsa3/pki |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
$ ./easyrsa construya-ca Utilizando SSL: openssl LibreSSL 2.8.3 Entre en Nuevo CA Clave Frase de contraseña: Re-Entre en Nuevo CA Clave Frase de contraseña: Generar RSA privado clave, 2048 bit largo módulo ..........................................+++ ................................................................+++ e es 65537 (0x10001) Usted son acerca de a sea preguntó a entre en información que se sea incorporado en su certificado solicitar. Qué usted son acerca de a entre en es qué es llamado a Distinguido Nombre o a DN. Allí son muy a algunos campos pero usted puede dejar algunos en blanco Para algunos campos allí se sea a por defecto valor, Si usted entre en '.', el campo se sea izquierda en blanco. ----- Común Nombre (eg: su usuario, host, o servidor nombre) [Fácil-RSA CA]:Couchbase CA CA creación completa y usted mayo ahora importar y firmar cert solicita. Su nuevo CA certificado archivo para publicación es en: /Usuarios/balajinarayanan/k8s/couchbase/operador/tls/fácil-rsa/easyrsa3/pki/ca.crt |
3. Cree el certificado del servidor de clúster Couchbase.
Necesitas crear un certificado comodín de servidor y una clave para ser usada en los pods de Couchbase Server. En este artículo, vamos a utilizar el siguiente comando para generar un certificado para el clúster Couchbase cbopedns en el demo y utilizando el espacio de nombres cbdemo.balajiacloud.guru subdominio.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
$ ./easyrsa --tema-alt-nombre="DNS:*.cbopedns,DNS:*.cbopedns.demo,DNS:*.cbopedns.demo.svc,DNS:*.demo.svc,DNS:cbopedns-srv,DNS:cbopedns-srv.demo,DNS:cbopedns-srv.demo.svc,DNS:localhost,DNS:*.cbopedns.cbdemo.balajiacloud.guru,DNS:*.cbdemo.balajiacloud.guru" construya-servidor-completo couchbase-servidor nopass Utilizando SSL: openssl LibreSSL 2.8.3 Generar a 2048 bit RSA privado clave ..............................+++ .......................................................+++ escribir nuevo privado clave a '/Users/balajinarayanan/k8s/couchbase/operator/tls/easy-rsa/easyrsa3/pki/easy-rsa-10086.2Q0Q2S/tmp.emWXHL' ----- Utilizando configuración de /Usuarios/balajinarayanan/k8s/couchbase/operador/tls/fácil-rsa/easyrsa3/pki/fácil-rsa-10086.2Q0Q2S/tmp.Phz9Az Entre en pase frase para /Usuarios/balajinarayanan/k8s/couchbase/operador/tls/fácil-rsa/easyrsa3/pki/privado/ca.clave: Consulte que el solicitar coincide con el firma Firma ok En Asuntoes el siguiente commonName :ASN.1 12:'couchbase-servidor' Certificado es a sea certificado hasta Agosto 5 17:44:19 2022 GMT (825 días) Escriba a fuera base de datos con 1 nuevo entradas Datos Base Actualizado |
Nota: Las claves protegidas por contraseña no son soportadas por Couchbase Server o el Operador.
El par clave/certificado se encuentra en pki/private/couchbase-server.key y pki/issued/couchbase-server.crt y se utiliza como pkey.key y cadena.pemrespectivamente, en el spec.networking.tls.static.serverSecret parámetro de agrupación.
4. Formateo de claves privadas - Debido a una limitación con el manejo de claves privadas de Couchbase Server, las claves del servidor deben tener formato PKCS#1.
En primer lugar, copiemos los archivos .key y .pem en la carpeta tls para facilitar el acceso.
|
1 2 3 4 5 |
$ cp fácil-rsa/easyrsa3/pki/privado/couchbase-servidor.clave pkey.clave $ cp fácil-rsa/easyrsa3/pki/publicado/couchbase-servidor.crt cadena.pem $ cp fácil-rsa/easyrsa3/pki/ca.crt ca.crt |
Ahora, vamos a formatear las claves del servidor.
|
1 2 |
$ openssl rsa -en pkey.clave -fuera pkey.clave.der -formulario DER escribir RSA clave |
|
1 2 |
$ openssl rsa -en pkey.clave.der -informar DER -fuera pkey.clave -formulario PEM escribir RSA clave |
Utilizaremos estas claves para crear el secreto del servidor del cluster Couchbase.
Despliegue Couchbase Autonomous Operator 2.0 (Última versión)
Couchbase Autonomous Operator for Kubernetes permite la portabilidad a la nube y automatiza las mejores prácticas operativas para desplegar y gestionar Couchbase.
El operador está formado por dos componentes: un controlador dinámico de admisión (DAC) por clúster y un operador por espacio de nombres. Consulte el arquitectura del operador para obtener información adicional sobre los requisitos y las consideraciones de seguridad.
1. Descargar el paquete Operator
Puede descargar la última Operador autónomo de Couchbase y descomprímalo en el equipo local. El paquete Operator contiene archivos de configuración YAML y herramientas de línea de comandos que utilizará para instalar Operator.
2. Instale la definición personalizada de recursos (CRD)
El primer paso para instalar Operator es instalar las definiciones de recursos personalizadas (CRD) que describen los tipos de recursos de Couchbase. Esto se puede lograr ejecutando el siguiente comando desde el directorio del paquete Operator:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
$ kubectl crear -f crd.yaml definición personalizada de recursos.apiextensions.k8s.io/couchbasebuckets.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbaseephemeralbuckets.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbasememcachedbuckets.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbasereplications.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbaseusers.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbasegroups.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbaserolebindings.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbaseclusters.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbasebackups.couchbase.com creado definición personalizada de recursos.apiextensions.k8s.io/couchbasebackupresores.couchbase.com creado |
3. Instalar el Controlador Dinámico de Admisión (DAC)
El DAC permite modificar e interrogar los recursos personalizados antes de aceptarlos y comprometerlos a etcd. Ejecutar el DAC nos permite añadir valores por defecto sensibles a las configuraciones del cluster Couchbase minimizando así el tamaño de las especificaciones. También nos permite mantener la compatibilidad con versiones anteriores cuando se añaden nuevos atributos y deben ser rellenados. Esto hace que la experiencia de uso de los recursos de Couchbase sea similar a la de los tipos de recursos nativos.
Ahora, vamos a instalar el Controlador Dinámico de Admisión.
Abra una ventana de Terminal y vaya al directorio donde desempaquetó el paquete Operator y cd a la carpeta bin. Ejecute el siguiente comando para instalar el DAC en la carpeta por defecto espacio de nombres.
|
1 2 3 4 5 6 7 8 9 10 |
$ ./cbopcfg --no-operador --espacio de nombres por defecto | kubectl crear -n por defecto -f - cuenta de servicio/couchbase-operador-admisión creado clusterrole.rbac.autorización.k8s.io/couchbase-operador-admisión creado clusterrolebinding.rbac.autorización.k8s.io/couchbase-operador-admisión creado secreto/couchbase-operador-admisión creado despliegue.aplicaciones/couchbase-operador-admisión creado servicio/couchbase-operador-admisión creado mutatingwebhookconfiguration.admisióninscripción.k8s.io/couchbase-operador-admisión creado validatingwebhookconfiguration.admisióninscripción.k8s.io/couchbase-operador-admisión creado |
Confirme que el controlador de admisión se ha desplegado correctamente.
|
1 2 3 4 |
$ kubectl consiga despliegues NOMBRE LISTO UP-A-FECHA DISPONIBLE EDAD couchbase-operador-admisión 1/1 1 1 70s |
4. Crear un espacio de nombres
Los espacios de nombres son una forma de asignar recursos de clúster, además de establecer políticas de red y seguridad entre varias aplicaciones. Crearemos un espacio de nombres único llamado demo para desplegar el Operator y más tarde utilizaremos el espacio de nombres demo para desplegar el cluster Couchbase.
Ejecute el siguiente comando para crear el espacio de nombres.
|
1 2 3 |
$ kubectl crear espacio de nombres demo espacio de nombres/demo creado |
Confirme que el espacio de nombres se ha creado correctamente.
|
1 2 3 4 5 6 7 8 |
$ kubectl consiga espacios de nombres NOMBRE ESTADO EDAD por defecto Activo 37m demo Activo 39s kube-nodo-arrendamiento Activo 37m kube-público Activo 37m kube-sistema Activo 37m |
5. Configurar TLS
Los secretos se especifican en el recurso CouchbaseCluster, y lo notarás en el YAML de definición del cluster mientras desplegamos el cluster Couchbase.
Secreto de servidor
Los secretos de servidor deben montarse como un volumen dentro del pod de Couchbase Server con nombres específicos. La cadena de certificados debe llamarse cadena.pem y la clave privada como pkey.key. Ejecute el siguiente comando para crear el secreto del servidor Couchbase.
|
1 2 3 |
$ kubectl crear secreto genérico couchbase-servidor-tls -n demo --de-archivo tls/cadena.pem --de-archivo tls/pkey.clave secreto/couchbase-servidor-tls creado |
Secreto del operador
Los secretos de cliente de Operator se leen directamente de la API. Sólo se espera un único valor; ca.crt es la CA de nivel superior que se utiliza para autenticar todas las cadenas de certificados de servidor TLS. Ejecute el siguiente comando para crear el Operator secret.
|
1 2 3 |
$ kubectl crear secreto genérico couchbase-operador-tls -n demo --de-archivo tls/ca.crt secreto/couchbase-operador-tls creado |
6. Instalar el operador Couchbase
Ahora vamos a desplegar el Operador en el directorio demo ejecutando el siguiente comando desde la carpeta bin del directorio del paquete Operator.
|
1 2 3 4 5 6 7 |
$ ./cbopcfg --no-admisión --espacio de nombres demo | kubectl crear -n demo -f - cuenta de servicio/couchbase-operador creado papel.rbac.autorización.k8s.io/couchbase-operador creado vinculación de funciones.rbac.autorización.k8s.io/couchbase-operador creado despliegue.aplicaciones/couchbase-operador creado servicio/couchbase-operador creado |
Al ejecutar el comando anterior se descarga la imagen Docker Operator y se crea un archivo despliegueque gestiona una única instancia de Operator. El pod Operator se ejecuta como despliegue para que Kubernetes pueda reiniciarse en caso de fallo.
Después de ejecutar el kubectl create por lo general, Kubernetes tarda menos de un minuto en desplegar el operador y dejarlo listo para ejecutarse.
Comprobar el estado de la implantación del operador
Puede utilizar el siguiente comando para comprobar el estado de la implantación:
|
1 2 3 4 |
$ kubectl consiga despliegues -n demo NOMBRE LISTO UP-A-FECHA DISPONIBLE EDAD couchbase-operador 1/1 1 1 97s |
Si ejecuta este comando inmediatamente después de desplegar el Operador, la salida tendrá el valor DISPONIBLE como 0. Sin embargo, el campo AVAILABLE indica que el pod aún no está listo, ya que su valor es 0 y no 1.
Ejecute el siguiente comando para verificar que el pod Operator se ha iniciado correctamente. Si Operator está en funcionamiento, el comando devuelve una salida en la que se muestra el icono LISTO exposiciones sobre el terreno 1/1como:
|
1 2 3 4 |
$ kubectl consiga vainas -l aplicación=couchbase-operador -n demo NOMBRE LISTO ESTADO RESTARTS EDAD couchbase-operador-7f799565f8-c29ts 1/1 Ejecutar 0 2m47s |
También puede comprobar los registros para confirmar que el Operador está en funcionamiento, ejecutando el siguiente comando.
|
1 2 3 4 5 6 7 8 9 |
$ kubectl Registros -f couchbase-operador-7f799565f8-c29ts -n demo {"nivel":"info","ts":1588493860.1096337,"logger":"principal","msg":"couchbase-operator","version":"2.0.0 (build 317)","revisión":"liberación"} {"nivel":"info","ts":1588493860.1100397,"logger":"líder","msg":"Intentando convertirme en el líder".} {"nivel":"info","ts":1588493860.1653795,"logger":"líder","msg":"No se encontró ninguna cerradura preexistente".} {"nivel":"info","ts":1588493860.1700613,"logger":"líder","msg":"Se convirtió en el líder".} {"nivel":"info","ts":1588493860.2087,"logger":"kubebuilder.controller","msg":"Iniciando EventSource","controlador":"couchbase-controller","fuente":"kind source /, Kind="} {"nivel":"info","ts":1588493860.3104734,"logger":"kubebuilder.controller","msg":"Controlador de arranque","controlador":"couchbase-controller"} {"nivel":"info","ts":1588493860.4107096,"logger":"kubebuilder.controller","msg":"Trabajadores principiantes","controlador":"couchbase-controller","recuento de trabajadores":4} |
Despliegue del DNS externo
Suponiendo que ya ha completado los pasos anteriores para desplegar el Operador en un espacio de nombres; la función demo lo siguiente que hay que instalar es el controlador DNS externo. Esto debe instalarse antes que el cluster Couchbase ya que el Operador esperará a la propagación DNS antes de crear en pods Couchbase Server. Esto se debe a que los clientes deben ser capaces de llegar a los pods de Couchbase Server con el fin de servir el tráfico y evitar errores de aplicación.
1. Cree una cuenta de servicio para el controlador DNS externo en el espacio de nombres donde va a instalar el Operator.
|
1 2 3 |
$ kubectl --espacio de nombres demo crear cuenta de servicio externo-dns cuenta de servicio/externo-dns creado |
2. El controlador DNS externo requiere un rol para poder sondear recursos y buscar registros DNS para replicar en el proveedor DDNS.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
$ kubectl --espacio de nombres demo crear -f - <<EOF apiVersion: rbac.autorización.k8s.io/v1beta1 amable: ClusterRole metadatos: nombre: externo-dns normas: - apiGroups: [""] recursos: ["servicios","puntos finales","vainas"] verbos: ["get","reloj","lista"] - apiGroups: ["extensiones"] recursos: ["entradas"] verbos: ["get","reloj","lista"] - apiGroups: [""] recursos: ["nodos"] verbos: ["get","reloj","lista"] EOF clusterrole.rbac.autorización.k8s.io/externo-dns creado |
3. Ahora, vincule el rol DNS externo a la cuenta de servicio.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
$ kubectl --espacio de nombres demo crear -f - <<EOF apiVersion: rbac.autorización.k8s.io/v1beta1 amable: ClusterRoleBinding metadatos: nombre: externo-dns roleRef: apiGroup: rbac.autorización.k8s.io amable: ClusterRole nombre: externo-dns temas: - amable: CuentaServicio nombre: externo-dns espacio de nombres: demo EOF clusterrolebinding.rbac.autorización.k8s.io/externo-dns creado |
4. El último paso es desplegar el DNS externo. No olvide actualizar los siguientes valores específicos para su despliegue.
-
- En spec.template.spec.serviceAccountName garantiza que los pods DNS externos se ejecutan como la cuenta de servicio que hemos configurado. Esto concede al controlador permiso para sondear recursos y buscar solicitudes DDNS.
- En -filtro de dominio indica a DNS Externo que sólo tenga en cuenta las entradas DDNS que estén asociadas a entradas DNS relacionadas con nuestro balajiacloud.guru dominio.
- En -txt-id-propietario indica a DNS Externo que etiquete los registros de gestión TXT con una cadena exclusiva de la instancia de DNS Externo. DNS externo utiliza registros TXT para registrar metadatos , especialmente información de propiedad asociada con los registros DNS que está administrando. Si el argumento balajiacloud.guru es utilizado por múltiples instancias de DNS Externo sin especificar ninguna propiedad, entonces entrarían en conflicto entre sí.
- En CF_API_KEY es utilizada por el proveedor de Cloudflare para autenticarse en la API de Cloudflare.
- En CF_API_EMAIL es utilizada por el proveedor de Cloudflare para identificar qué cuenta utilizar contra la API de Cloudflare.
Puedes obtener el CF_API_KEY desde la página de resumen de la cuenta de Cloudfare. Haz clic en el enlace "Obtén tu token de API" como se muestra a continuación y visualiza el Clave API global.
Despliegue del DNS externo
Por último, instale el despliegue de DNS externo ejecutando el siguiente comando.
|
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 |
$ kubectl --espacio de nombres demo crear -f - <<EOF apiVersion: aplicaciones/v1 amable: Despliegue metadatos: nombre: externo-dns spec: selector: matchLabels: aplicación: externo-dns plantilla: metadatos: etiquetas: aplicación: externo-dns spec: serviceAccountName: externo-dns contenedores: - nombre: externo-dns imagen: registro.opensource.zalan.do/tetera/externo-dns:última args: - --fuente=servicio - --dominio-filtro=balajiacloud.gurú - --proveedor=cloudflare - --txt-propietario-id=cbop-edns-demo env: - nombre: CF_API_KEY valor: SU_CLAVE_CF_API - nombre: CF_API_EMAIL valor: SU_CF_API_EMAIL EOF despliegue.aplicaciones/externo-dns creado |
Comprobar el estado de la implantación del DNS externo
Puede utilizar el siguiente comando para comprobar el estado de la implantación:
|
1 2 3 4 5 |
$ kubectl consiga despliegues -n demo NOMBRE LISTO UP-A-FECHA DISPONIBLE EDAD couchbase-operador 1/1 1 1 10m externo-dns 1/1 1 1 21s |
Ejecute el siguiente comando para verificar que el external-dns se ha iniciado correctamente. Si el external-dns está en funcionamiento, el comando devuelve una salida en la que se muestra el icono RUNNING exposiciones sobre el terreno 1/1como:
|
1 2 3 4 5 |
$ kubectl consiga vainas -n demo NOMBRE LISTO ESTADO RESTARTS EDAD couchbase-operador-7f799565f8-c29ts 1/1 Ejecutar 0 11m externo-dns-6f74575d54-fp2wh 1/1 Ejecutar 0 59s |
También puede comprobar los registros para confirmar que external-dns está en funcionamiento.
|
1 2 3 4 5 6 |
$ kubectl Registros -f externo-dns-6f74575d54-fp2wh -n demo tiempo="2020-05-03T08:27:44Z" nivel=información msg="config: {Master: KubeConfig: RequestTimeout:30s IstioIngressGatewayServices:[] ContourLoadBalancerService:heptio-contour/contour SkipperRouteGroupVersion:zalando.org/v1 Sources:[service] Namespace: AnnotationFilter: FQDNTemplate: CombineFQDNAndAnnotation:false IgnoreHostnameAnnotation:false Compatibilidad: PublishInternal:false PublishHostIP:false AlwaysPublishNotReadyAddresses:false ConnectorSourceServer:localhost:8080 Provider:cloudflare GoogleProject: GoogleBatchChangeSize:1000 GoogleBatchChangeInterval:1s DomainFilter:[balajiacloud.guru] ExcludeDomains:[] ZoneIDFilter:[] AlibabaCloudConfigFile:/etc/kubernetes/alibaba-cloud.json AlibabaCloudZoneType: AWSZoneType: AWSZoneTagFilter:[] AWSAssumeRole: AWSBatchChangeSize:1000 AWSBatchChangeInterval:1s AWSEvaluateTargetHealth:true AWSAPIRetries:3 AWSPreferCNAME:false AzureConfigFile:/etc/kubernetes/azure.json AzureResourceGroup: AzureSubscriptionID: AzureUserAssignedIdentityClientID: CloudflareProxied:false CloudflareZonesPerPage:50 CoreDNSPrefix:/skydns/ RcodezeroTXTEncrypt:false AkamaiServiceConsumerDomain: AkamaiClientToken: AkamaiClientSecret: AkamaiAccessToken: InfobloxGridHost: InfobloxWapiPort:443 InfobloxWapiUsername:admin InfobloxWapiPassword: InfobloxWapiVersion:2.3.1 InfobloxSSLVerify:true InfobloxView: InfobloxMaxResults:0 DynCustomerName: DynUsername: DynPassword: DynMinTTLSeconds:0 OCIConfigFile:/etc/kubernetes/oci.yaml InMemoryZones:[] OVHEndpoint:ovh-eu PDNSServer:http://localhost:8081 PDNSAPIKey: PDNSTLSEnabled:false TLSCA: TLSClientCert: TLSClientCertKey: Policy:sync Registry:txt TXTOwnerID:cbop-edns-demo TXTPrefix: Interval:1m0s Once:false DryRun:false UpdateEvents:false LogFormat:text MetricsAddress::7979 LogLevel:info TXTCacheInterval:0s ExoscaleEndpoint:https://api.exoscale.ch/dns ExoscaleAPIKey: ExoscaleAPISecret: CRDSourceAPIVersion:externaldns.k8s.io/v1alpha1 CRDSourceKind:DNSEndpoint ServiceTypeFilter:[] CFAPIEndpoint: CFUsername: CFPassword: RFC2136Host: RFC2136Port:0 RFC2136Zone: RFC2136Insecure:false RFC2136TSIGKeyName: RFC2136TSIGSecret: RFC2136TSIGSecretAlg: RFC2136TAXFR:false RFC2136MinTTL:0s NS1Endpoint: NS1IgnoreSSL:false TransIPAccountName: TransIPPrivateKeyFile:}" tiempo="2020-05-03T08:27:44Z" nivel=información msg="Instanciando nuevo cliente Kubernetes" tiempo="2020-05-03T08:27:44Z" nivel=información msg="Uso de inCluster-config basado en serviceaccount-token" tiempo="2020-05-03T08:27:44Z" nivel=información msg="Creado cliente Kubernetes https://10.100.0.1:443" |
Ahora hemos desplegado con éxito el DNS externo.
Despliegue del clúster Couchbase
Ahora que hemos desplegado el Operador Autónomo Couchbase y el DNS Externo en EKS, vamos a desplegar el Cluster Couchbase.
Desplegaremos el cluster Couchbase con 3 nodos de datos en 3 zonas de disponibilidad con los parámetros de configuración mínimos requeridos. Consulte la Configurar la red pública para las opciones de configuración necesarias.
Crear el secreto para la consola de administración de Couchbase
Vamos a crear una credencial secreta que será utilizada por la consola web administrativa durante el inicio de sesión. Al crear el siguiente secreto en su clúster Kubernetes, el secreto establece el nombre de usuario en Administrador y la contraseña a contraseña.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
$ kubectl --espacio de nombres demo crear -f - <<EOF apiVersion: v1 amable: Secreto metadatos: nombre: cb-ejemplo-auth tipo: Opaco datos: nombre de usuario: QWRtaW5pc3RyYXRvcg== Administrador # contraseña: cGFzc3dvcmQ= Contraseña # EOF secreto/cbopedns-auth creado |
Despliegue de la definición del clúster Couchbase
Utilizaremos la opción por defecto StorageClass que obtenemos con EKS, comprobémoslo ejecutando el siguiente comando. Puedes crear una clase de almacenamiento que se ajuste a tus necesidades.
|
1 2 3 4 |
$ kubectl consiga sc NOMBRE PROVISIONADOR EDAD gp2 (por defecto) kubernetes.io/aws-ebs 67m |
Para desplegar un clúster de Couchbase Server utilizando el Operador, todo lo que tienes que hacer es crear una definición de clúster de Couchbase que describa cómo quieres que sea el clúster (por ejemplo, el número de nodos, tipos de servicios, recursos del sistema, etc), y luego empujar esa definición de clúster en Kubernetes.
El paquete Operator contiene un archivo de definición de CouchbaseCluster de ejemplo (couchbase-cluster.yaml).
La siguiente definición de cluster desplegará el cluster Couchbase con 3 pods de datos a través de 3 zonas diferentes utilizando volúmenes persistentes. Por favor, compruebe la Recurso de clúster de Couchbase para obtener la lista completa de la configuración del clúster.
|
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
$ kubectl --espacio de nombres demo crear -f - <<EOF apiVersion: couchbase.com/v2 amable: CouchbaseBucket metadatos: nombre: por defecto --- apiVersion: couchbase.com/v2 amable: CouchbaseCluster metadatos: nombre: cbopedns spec: imagen: couchbase/servidor:6.5.0 red: tls: estático: serverSecret: couchbase-servidor-tls operatorSecret: couchbase-operador-tls exposeAdminConsole: verdadero adminConsoleServiceType: LoadBalancer características expuestas: - xdcr - cliente exposedFeatureServiceType: LoadBalancer dns: dominio: cbdemo.balajiacloud.gurú disableBucketManagement: falso grupo: clusterName: cbopedns dataServiceMemoryQuota: 2048Mi seguridad: adminSecret: cbopedns-auth servidores: - nombre: datos-este-1a talla: 1 servicios: - datos grupos de servidores: - us-este-1a vaina: volumeMounts: por defecto: pvc-por defecto # /opt/couchbase/var/lib/couchbase datos: pvc-datos # /mnt/data - nombre: datos-este-1b talla: 1 servicios: - datos grupos de servidores: - us-este-1b vaina: volumeMounts: por defecto: pvc-por defecto datos: pvc-datos - nombre: datos-este-1c talla: 1 servicios: - datos grupos de servidores: - us-este-1c vaina: volumeMounts: por defecto: pvc-por defecto datos: pvc-datos volumeClaimTemplates: - metadatos: nombre: pvc-por defecto spec: storageClassName: gp2 recursos: solicita: almacenamiento: 1Gi - metadatos: nombre: pvc-datos spec: storageClassName: gp2 recursos: solicita: almacenamiento: 5Gi EOF couchbasebucket.couchbase.com/por defecto creado couchbasecluster.couchbase.com/cbopedns creado |
Tras recibir la configuración, el Operador inicia automáticamente la creación del clúster. El tiempo que se tarda en crear el clúster depende de la configuración. Puede seguir el progreso de la creación del clúster utilizando la función estado del clúster.
Verificación de la implantación
Para comprobar el progreso ejecute el siguiente comando, que observará (argumento -w) el progreso de la creación de pods. Si todo va bien entonces tendremos tres pods del cluster Couchbase alojando los servicios según la definición del cluster Couchbase.
|
1 2 3 4 5 6 7 |
kubectl consiga vainas --espacio de nombres demo -w cbopedns-0000 1/1 Ejecutar 0 9m15s cbopedns-0001 1/1 Ejecutar 0 8m34s cbopedns-0002 1/1 Ejecutar 0 8m couchbase-operador-7f799565f8-c29ts 1/1 Ejecutar 1 36m externo-dns-6f74575d54-fp2wh 1/1 Ejecutar 0 26m |
Si por alguna razón se produce una excepción, puede encontrar los detalles de la excepción en el archivo de registro couchbase-operator. Para visualizar las últimas 20 líneas del registro, copie el nombre de su pod Operator y ejecute el siguiente comando sustituyendo el nombre del pod Operator por el nombre de su entorno.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
$ kubectl Registros couchbase-operador-7f799565f8-c29ts -n demo --cola 20 {"nivel":"info","ts":1588495709.7896624,"logger":"cluster","msg":"Viendo nuevo cluster","cluster":"demo/cbopedns"} {"nivel":"info","ts":1588495709.7898946,"logger":"cluster","msg":"Conserje empezando","cluster":"demo/cbopedns"} {"nivel":"info","ts":1588495709.7987065,"logger":"cluster","msg":"Cliente Couchbase iniciándose","cluster":"demo/cbopedns"} {"nivel":"info","ts":1588495709.818881,"logger":"cluster","msg":"El clúster ya existe, ahora lo gestionará el operador","cluster":"demo/cbopedns"} {"nivel":"info","ts":1588495709.8903878,"logger":"cluster","msg":"Corriendo","cluster":"demo/cbopedns"} {"nivel":"info","ts":1588495710.0405645,"logger":"couchbaseutil","msg":"Estado del cluster","cluster":"demo/cbopedns","equilibrio":"desequilibrado","reequilibrio":falso} {"nivel":"info","ts":1588495710.0406282,"logger":"couchbaseutil","msg":"Estado del nodo","cluster":"demo/cbopedns","nombre":"cbopedns-0000","version":"6.5.0","clase":"data-east-1a","gestionado":verdadero,"status":"activo"} {"nivel":"info","ts":1588495710.0406532,"logger":"couchbaseutil","msg":"Estado del nodo","cluster":"demo/cbopedns","nombre":"cbopedns-0001","version":"6.5.0","clase":"data-east-1b","gestionado":verdadero,"status":"pendiente_añadir"} {"nivel":"info","ts":1588495710.040662,"logger":"couchbaseutil","msg":"Estado del nodo","cluster":"demo/cbopedns","nombre":"cbopedns-0002","version":"6.5.0","clase":"data-east-1c","gestionado":verdadero,"status":"pendiente_añadir"} {"nivel":"info","ts":1588495710.0406775,"logger":"programador","msg":"Estado del programador","cluster":"demo/cbopedns","nombre":"cbopedns-0000","clase":"data-east-1a","grupo":"us-east-1a"} {"nivel":"info","ts":1588495710.0406868,"logger":"programador","msg":"Estado del programador","cluster":"demo/cbopedns","nombre":"cbopedns-0001","clase":"data-east-1b","grupo":"us-east-1b"} {"nivel":"info","ts":1588495710.040695,"logger":"programador","msg":"Estado del programador","cluster":"demo/cbopedns","nombre":"cbopedns-0002","clase":"data-east-1c","grupo":"us-east-1c"} {"nivel":"info","ts":1588495755.230221,"logger":"couchbaseutil","msg":"Reequilibrio","cluster":"demo/cbopedns","progreso":0} {"nivel":"info","ts":1588495759.2380211,"logger":"cluster","msg":"Reequilibrio completado con éxito","cluster":"demo/cbopedns"} {"nivel":"info","ts":1588495759.286947,"logger":"cluster","msg":"Conciliación completada","cluster":"demo/cbopedns"} |
Asegurémonos de comprobar los registros de external-dns para ver si se están creando los registros DNS para los pods de Couchbase.
|
1 2 3 4 5 6 7 8 |
$ kubectl Registros -f externo-dns-6f74575d54-fp2wh -n demo tiempo="2020-05-03T08:46:46Z" nivel=información msg="Cambiando de registro". acción=CREAR registro=cbopedns-0000.cbdemo.balajiacloud.guru objetivos=1 ttl=1 tipo=CNAME zona=c3b835b8ec89e43a2492b62d5d82cc86 tiempo="2020-05-03T08:46:46Z" nivel=información msg="Cambiando de registro". acción=CREAR registro=cbopedns-0002.cbdemo.balajiacloud.guru objetivos=1 ttl=1 tipo=CNAME zona=c3b835b8ec89e43a2492b62d5d82cc86 tiempo="2020-05-03T08:46:47Z" nivel=información msg="Cambiando de registro". acción=CREAR registro=cbopedns-0001.cbdemo.balajiacloud.guru objetivos=1 ttl=1 tipo=CNAME zona=c3b835b8ec89e43a2492b62d5d82cc86 tiempo="2020-05-03T08:46:47Z" nivel=información msg="Cambiando de registro". acción=CREAR registro=cbopedns-0000.cbdemo.balajiacloud.guru objetivos=1 ttl=1 tipo=TXT zona=c3b835b8ec89e43a2492b62d5d82cc86 tiempo="2020-05-03T08:46:47Z" nivel=información msg="Cambiando de registro". acción=CREAR registro=cbopedns-0002.cbdemo.balajiacloud.guru objetivos=1 ttl=1 tipo=TXT zona=c3b835b8ec89e43a2492b62d5d82cc86 tiempo="2020-05-03T08:46:47Z" nivel=información msg="Cambiando de registro". acción=CREAR registro=cbopedns-0001.cbdemo.balajiacloud.guru objetivos=1 ttl=1 tipo=TXT zona=c3b835b8ec89e43a2492b62d5d82cc86 |
En este punto, también puede comprobar la página DNS accediendo a su Cloudfare cuenta. Puede ver los registros CNAME y TXT añadidos por su proveedor de DNS externo.
Acceso a la consola web de Couchbase
Ahora, tienes un cluster direccionable públicamente que puedes empezar a usarlo. En el entorno EKS, se puede acceder a la consola web de Couchbase a través de un servicio LoadBalancer expuesto de un pod específico. Debería poder conectarse a la consola de Couchbase utilizando la URL https://cbopedns-0000.cbdemo.balajiacloud.guru:18091/ (sustituya el nombre del pod y el dominio DNS en función de su entorno).
Consulte Acceder a la interfaz de usuario del servidor Couchbase para más detalles sobre cómo conectarse a la consola de Couchbase. También puedes consultar Configurar SDK de cliente para más detalles sobre cómo conectar el SDK cliente con el cluster de Couchbase mientras se usa DNS Based Addressing con DNS Externo.
Conclusión
En este blog, vimos cómo el clúster Couchbase puede ser direccionable públicamente usando Couchbase Operator con Kubernetes External DNS. Hablamos de cómo la solución de DNS externo ayuda a gestionar dinámicamente los registros DNS externos desde dentro de un clúster Kubernetes. En este artículo, hemos utilizado Amazon EKS como nuestro entorno Kubernetes, pero los mismos pasos también serían aplicables si está utilizando otros entornos Kubernetes como AKS, GKE, OpenShift, etc.
Recursos
- Pruébalo: Descargar Couchbase Autonomous Operator 2.0
- Comparta su opinión sobre el Foros de Couchbase
- Documentación:
Gracias Balaji. Esto es útil.
¿Es necesario registrar un nuevo dominio DNS público? Quiero decir, un dominio aws (por ejemplo, ap-sur-1.elb.amazonaws.com) no se puede utilizar, puede ser con un subdominio?