Importante: Esta documentación asume un conocimiento de Helm y los gráficos de Helm y no intenta proporcionar ejemplos detallados y prescriptivos. Está diseñado para clientes que están familiarizados con Tableau Server y Helm y con los gráficos de Helm.

Este tema lo guía a través de los pasos de alto nivel para implementar Tableau Server en Kubernetes mediante un gráfico de Helm.

Requisitos previos

Antes de empezar, asegúrese de que cumple los requisitos previos. Para más información, consulte Gráfico de Helm de Tableau Server: requisitos previos.

Descripción general rápida sobre el uso de un gráfico de Helm para implementar Tableau Server

Importante: Esta es una descripción básica sobre la implementación de Tableau Server mediante gráficos de Helm. No es el procedimiento completo. Se presupone el conocimiento de Helm y los gráficos de Helm.

Antes de comenzar, asegúrese de cumplir los requisitos previos para implementar Tableau Server mediante gráficos de Helm. Consulte Gráfico de Helm de Tableau Server: requisitos previos para obtener información detallada.

Implementar Tableau Server de un solo nodo

Implemente una instancia de nodo único de Tableau Server ejecutando estos comandos en un símbolo del sistema (sustituya el espacio de nombres de su versión por <namespace>, por ejemplo tableau o default):

helm install tableau-server ./helm/tableau-server \
  -n <namespace> \
  --create-namespace \
  -f ./helm/tableau-server/values-single.yaml

Implementar Tableau Server de varios nodos

Implemente una instancia de varios nodos de Server ejecutando estos comandos en un símbolo del sistema, utilizando la misma convención de espacio de nombres que la anterior:

helm install tableau-server ./helm/tableau-server \
-n <namespace> \
--create-namespace \
-f ./helm/tableau-server/values-multinode.yaml

Runbook multinodo de EKS (espacio de nombres + PV de arranque estático)

En esta sección se describe el orden de las operaciones para EKS: espacio de nombres dedicado, complemento EFS CSI, IAM en el rol de nodo, PV de arranque estático y Helm.

1. Cree un espacio de nombres dedicado.

   Esto debe coincidir con claimFef.namespace en el PV de arranque. Este ejemplo usa tableau.

   kubectl create namespace tableau-server
   kubectl get namespace tableau

2. Confirme que el complemento EFS CSI existe.

   Si falta el complemento, créelo y espere hasta que el estado sea ACTIVE:

   kubectl get csidriver efs.csi.aws.com
   aws eks describe-addon \
     --cluster-name <cluster-name> \  
     --addon-name aws-efs-csi-driver \
     --region <region> \
     --query 'addon.status'

3. Confirme la clase de almacenamiento:

   Clase de almacenamiento efs-bootstrap: aplicar si aún no está presente. Consulte Requisitos previos de Amazon Elastic Kubernetes Service (EKS) para obtener más información.

   kubectl get csidriver efs.csi.aws.com
   aws eks describe-addon \
     --cluster-name <cluster-name> \  
     --addon-name aws-efs-csi-driver \
     --region <region> \
     --query 'addon.status'

4. Confirme el PV de arranque estático.

   claimRef debe hacer referencia al mismo espacio de nombres y nombre de PVC que crea el gráfico de Helm (tableau-server-bootstrap). Reemplace fs-... con su ID de sistema de archivos EFS:

   cat > /tmp/tableau-bootstrap-pv.yaml <<'EOF'
   apiVersion: v1
   kind: PersistentVolume
   metadata:
     name: tableau-bootstrap-pv
   spec:
     capacity:
       storage: 1Gi
     volumeMode: Filesystem
     accessModes:
       - ReadWriteMany
   persistentVolumeReclaimPolicy: Retain
   storageClassName: efs-bootstrap
   claimRef:
     namespace: tableau
     name: tableau-server-bootstrap
   csi:
     driver: efs.csi.aws.com
     volumeHandle: <fs-xxxxxxxxxxxxxxxxx>
   EOF
   kubectl apply -f /tmp/tableau-bootstrap-pv.yaml
   kubectl get pv tableau-bootstrap-pv

5. IAM en el rol de instancia del nodo.

   Adjunte el cliente EFS y las directivas de solo lectura de EC2. Consulte Requisitos previos de Amazon Elastic Kubernetes Service (EKS) para resolver <your-node-instance-role> del grupo de nodos.

   Clase de almacenamiento efs-bootstrap: aplicar si aún no está presente. Consulte Requisitos previos de Amazon Elastic Kubernetes Service (EKS) para obtener más información.

   kubectl get csidriver efs.csi.aws.com
   aws eks describe-addon \
     --cluster-name <cluster-name> \  
     --addon-name aws-efs-csi-driver \
     --region <region> \
     --query 'addon.status'

6. Valores

   En values-multinode.yaml (o una superposición), establezca el modo fotovoltaico estático manual

   persistence:
     bootstrap:
       createPV: false
       volumeName: tableau-bootstrap-pv
       storageClass: efs-bootstrap

7. Asegúrese de image.repository, image.tagy secrets/license se establecen según sea necesario.

8. Instale el gráfico de Helm

   Instale el gráfico en el mismo espacio de nombres que el PV claimRef:

   helm install tableau-server ./helm/tableau-server \
     -n tableau \
     -f ./helm/tableau-server/values-multinode.yaml

9. Verifique el almacenamiento y los pods:

   kubectl get pv,pvc -n tableau
   kubectl get pods -n tableau -w

10. Estado de los PVC de datos

    Los PVC de datos pueden mostrar Pending brevemente hasta que se conecten los volúmenes de EBS. Todos los PVC deben hacer la transición a Bound, después Runningy, finalmente, READY 1/1.

11. Topología (opcional)

    Si el enlace posterior a la instalación está deshabilitado, es posible que deba configurar el nodo clustercontroller y aplicar los cambios pendientes (consulte Automatización de topología posterior a la instalación (enlace) más adelante en este documento). El comando tsm pending-changes apply puede generar advertencias sobre la distribución de Index and Search Server o el conjunto del servicio de coordinación cuando tiene varios nodos de Tableau. Aborde estas advertencias como se documenta en Index and Search Server y Servicio de coordinación de Tableau Server.

Instalación personalizada

1. Personalizar valores

   cp ./helm/tableau-server/values.yaml 
   ./helm/tableau-server/my-values.yaml
   # Edit ./helm/tableau-server/my-values.yaml with your configuration

2. Instalar con valores personalizados

   helm install tableau-server ./helm/tableau-server -f ./helm/tableau-server/my-values.yaml

Configuración

Modos de implementación

deploymentMode: "single"
primary:
  replicaCount: 1
worker:
  replicaCount: 0

deploymentMode: "multinode"
primary:
  replicaCount: 1
worker:
  replicaCount: 3    # example: three workers

Alineación de topología: values-multinode.yaml se envía con una topología config.configJson de muestra (ID de nodo como node1, node2, node3). Si cambia worker.replicaCount o reorganiza los servicios, actualice esa topología (y cualquier asignación de proceso de Tableau relacionada) para que el número y las funciones de los nodos de TSM coincidan con su implementación. Consulte la ayuda de Tableau Server para obtener información sobre la agrupación en clústeres y el diseño de procesos.

Opciones de configuración de clave

image:
  repository: tableau_server_image
  tag: "latest"
  pullPolicy: IfNotPresent
  pullSecrets: []

secrets:
  licenseKey: "YOUR-LICENSE-KEY"
  tsmRemotePassword: "password"
  tableauUsername: "admin"
  tableauPassword: "password"

Alternativamente, puede configurarlos usando variables de entorno:

env:
  LICENSE_KEY: "YOUR-LICENSE-KEY"
  TSM_REMOTE_PASSWORD: "password"
  TABLEAU_USERNAME: "admin"
  TABLEAU_PASSWORD: "password"

Recomendamos utilizar un archivo independiente (por ejemplo, secrets.yaml) y pasándolo con el switch -f.

secrets.yaml:

secrets:
  licenseKey: "YOUR-LICENSE-KEY"
  tsmRemotePassword: "YOUR-TSM-PASSWORD"
  tableauUsername: "YOUR-ADMIN-USER"
  tableauPassword: "YOUR-ADMIN-PASSWORD"

Ejemplo de instalación/actualización con secrets.yaml:

helm upgrade --install tableau-server ./helm/tableau-server \
  -n default \
  -f ./helm/tableau-server/values-multinode.yaml \
  -f ./helm/tableau-server/secrets.yaml

Nota: Hacer referencia a un secreto de Kubernetes preexistente (por ejemplo, secrets.existingSecret) no se admite actualmente. El único método admitido es usar valores de gráfico con un archivo de valores secretos separado.

# Discover command syntax for your Tableau version
kubectl exec -n default tableau-server-primary-0 -- sh -lc 'tsm topology external-services repository enable --help'
# After enabling external repository with Tableau-supported args/options:
kubectl exec -n default tableau-server-primary-0 -- sh -lc 'tsm pending-changes apply -iw --ignore-prompt'
kubectl exec -n default tableau-server-primary-0 -- sh -lc 'tsm status -v'

Almacenamiento persistente

persistence:
  enabled: true
  storageClass: "standard"
  accessMode: ReadWriteOnce
  size: 100Gi

  # Bootstrap volume (required for multi-node)
  bootstrap:
    enabled: true
    storageClass: "standard"
    accessMode: ReadWriteMany
    size: 1Gi
    createPV: false

Para clústeres que usan EFS CSI estático (por ejemplo, con mounttargetip), Helm puede administrar tanto PV como PVC de arranque:

persistence:
  bootstrap:
    enabled: true
    storageClass: "efs-bootstrap"
    accessMode: ReadWriteMany
    size: 1Gi
    createPV: true
    permissionsFix:
      enabled: true
    pv:
      name: "tableau-bootstrap-pv"
      csi:
        driver: efs.csi.aws.com
        volumeHandle: "fs-xxxxxxxx"
        volumeAttributes:
          mounttargetip: "10.x.x.x"

permissionsFix.enabled añade un contenedor init que chown/chmods /docker/config/bootstrap para que el proceso de Tableau (UID/GID 999:998) pueda escribir bootstrap.json en montajes EFS compartidos que son root:root de manera predeterminada.

Cuando createPV: true, el gráfico crea el PV de arranque a partir de valores (por ejemplo tableau-bootstrap-pv) y enlaza el PVC tableau-server-bootstrap a él.

Si administra el PV de arranque manualmente, cree tableau-bootstrap-pv primero, luego instale Helm con createPV: false y volumeName: tableau-bootstrap-pv:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: tableau-bootstrap-pv
spec:
  capacity:
    storage: 1Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  storageClassName: efs-bootstrap
  csi:
    driver: efs.csi.aws.com
    volumeHandle: fs-xxxxxxxx
    volumeAttributes:
      mounttargetip: 10.x.x.x

kubectl apply -f tableau-bootstrap-pv.yaml
kubectl get pv tableau-bootstrap-pv

Límites de recursos

primary:
  resources:
    limits:
      cpu: "4"
      memory: "8Gi"
    requests:
      cpu: "2"
      memory: "4Gi"

worker:
  resources:
    limits:
      cpu: "4"
      memory: "8Gi"
    requests:
      cpu: "2"
      memory: "4Gi"

Configuración del servicio

service:
  primary:
    type: ClusterIP  # or NodePort, LoadBalancer
    ports:
      http: 80
      https: 8080
      tsm: 8850

Ingress

ingress:
  enabled: true
  className: "nginx"
  hosts:
    - host: tableau.example.com
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: tableau-tls
      hosts:
        - tableau.example.com

Runbook de configuración de Ingress (ejemplo: controlador de ingreso NGINX)

1. Instale un controlador de Ingress en el clúster (requerido antes de habilitar la entrada del gráfico).

2. Establezca valores de Ingress en su archivo de valores:

   ingress:
     enabled: true
     className: "nginx"
     annotations:
       nginx.ingress.kubernetes.io/proxy-body-size: "64m"
       nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
       nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
     hosts:
       - host: tableau.example.com
         paths:
           - path: /
             pathType: Prefix
     tls:
       - secretName: tableau-tls
         hosts:
           - tableau.example.com

3. Cree un registro DNS que apunte a tableau.example.com a su extremo de ingress/equilibrador de carga.

4. Cree un secreto TLS (o use cert-manager) en el espacio de nombres de la versión.

5. Implementar/actualizar el gráfico y verificar el ingress:

   helm upgrade --install tableau-server ./helm/tableau-server -n default -f ./helm/tableau-server/values.yaml
   kubectl get ingress -n default
   kubectl describe ingress tableau-server

Para obtener más información, consulte:

• Concepto de Ingress de Kubernetes(El enlace se abre en una ventana nueva)

• Guía de implementación de ingress-nginx(El enlace se abre en una ventana nueva)

• Introducción a cert-manager(El enlace se abre en una ventana nueva)

Comprobaciones de estado

El gráfico admite sondas de inicio, vitalidad y preparación. La sonda de inicio permite una inicialización larga por primera vez (por ejemplo, failureThreshold: 200 × periodSeconds) antes de que se ejecute la actividad/preparación:

healthChecks:
  startup:
    enabled: true
    initialDelaySeconds: 300
    periodSeconds: 15
    timeoutSeconds: 30
    failureThreshold: 200
  liveness:
    enabled: true
    initialDelaySeconds: 300
    periodSeconds: 30
    timeoutSeconds: 10
    failureThreshold: 3
  readiness:
    enabled: true
    initialDelaySeconds: 300
    periodSeconds: 10
    timeoutSeconds: 5
    failureThreshold: 3

Para los pods de trabajadores de varios nodos, el gráfico tiene los valores predeterminados worker.healthChecks.enabled: false para evitar errores de sondeo falsos cuando los trabajadores ejecutan conjuntos de procesos limitados (por ejemplo, agente de administración + controlador de clúster solamente).

Uso

# Get pod name
POD_NAME=$(kubectl get pods -l app.kubernetes.io/component=primary -o jsonpath='{.items[0].metadata.name}')

# Run tabcmd
kubectl exec -it $POD_NAME -- tsm status
kubectl exec -it $POD_NAME -- tsm configuration get

# Get pod name
POD_NAME=$(kubectl get pods -l app.kubernetes.io/component=primary -o jsonpath='{.items[0].metadata.name}')

# Run tabcmd
kubectl exec -it $POD_NAME -- tabcmd login -u admin -p password
kubectl exec -it $POD_NAME -- tabcmd sites

# Primary node logs
kubectl logs -l app.kubernetes.io/component=primary -f

# Worker node logs (multi-node)
kubectl logs -l app.kubernetes.io/component=worker -f

# All logs
kubectl logs -l app.kubernetes.io/instance=tableau-server -f

# Get pod name
POD_NAME=$(kubectl get pods -l app.kubernetes.io/component=primary -o jsonpath='{.items[0].metadata.name}')

# Open shell
kubectl exec -it $POD_NAME -- /bin/bash

Actualización

Actualizar el gráfico de Helm de Tableau Server

helm upgrade tableau-server ./helm/tableau-server -f ./helm/tableau-server/values.yaml

Actualizar con nuevos valores

helm upgrade tableau-server ./helm/tableau-server -f ./helm/tableau-server/new-values.yaml

Automatización de topología posterior a la instalación (enlace)

Para instalaciones de varios nodos, este gráfico puede ejecutar un trabajo de enlace posterior a la instalación/actualización que:

• espera a que los nodos trabajadores se registren en TSM

• establece la asignación del proceso clustercontroller del trabajador

• ejecuta tsm pending-changes apply -iw --ignore-prompt cuando los cambios están pendientes

Configuración:

hooks:
  autoApplyWorkerTopology:
    enabled: true
    kubectlImage: "bitnami/kubectl:latest"
    timeoutSeconds: 3600

Valores predeterminado:

• deshabilitado en values.yaml

• en values-multinode.yaml, comprobar hooks.autoApplyWorkerTopology.enabled (puede ser true o false dependiendo de la versión; habilitar para la configuración de trabajadores no intervencionistas clustercontroller)

Verifique la ejecución del enlace:

kubectl get jobs -n default
kubectl get pods -n default -l job-name=tableau-server-hook-topology
kubectl logs -n default job/tableau-server-hook-topology

Fallback manual si el enlace está deshabilitado o falla: ejecute tsm topology set-process para cada nodo de TSM del trabajador (normalmente del nodo 2 al nodo (1+N) cuando tiene N trabajadores; confirme los ID con tsm topology list-nodes -v):

kubectl exec -n default tableau-server-primary-0 -- sh -lc '
tsm topology set-process -n node2 -pr clustercontroller -c 1
tsm topology set-process -n node3 -pr clustercontroller -c 1
# Add one line per additional worker node, e.g. for four workers:
# tsm topology set-process -n node4 -pr clustercontroller -c 1
# tsm topology set-process -n node5 -pr clustercontroller -c 1
tsm pending-changes apply -iw --ignore-prompt
tsm topology list-nodes -v

tsm status -v

Nota: Utilice -iw para tsm pending-changes apply. La opción -ig no es válida en este entorno.

Desinstalación

helm uninstall tableau-server

Advertencia: Esto eliminará todos los recursos, incluidos los volúmenes persistentes. Asegúrese de hacer una copia de seguridad de sus datos antes de desinstalar.

Pasos de validación

Antes del lanzamiento o al cambiar el gráfico, ejecute:

1. Lint:

   helm lint helm/tableau-server -f helm/tableau-server/values-single.yaml
   helm lint helm/tableau-server -f helm/tableau-server/values-multinode.yaml

2. Plantilla (ensayo):

   helm template tableau-server helm/tableau-server -f helm/tableau-server/values-single.yaml
   helm template tableau-server helm/tableau-server -f helm/tableau-server/values-multinode.yaml

3. Prueba de instalación (opcional):

   1. En un espacio de nombres de prueba, ejecute helm install con values-single o values-multinode.

   2. Ejecute kubectl rollout status (para StatefulSet, espere a que el pod esté listo) y comprobaciones de humo básicas (por ejemplo, tsm status o HTTP al servicio).

Para obtener información detallada sobre la solución de problemas, consulte Gráfico de Helm de Tableau Server: solución de problemas.

Recursos adicionales

• Documentación de Tableau Server(El enlace se abre en una ventana nueva)
• Documentación de Helm(El enlace se abre en una ventana nueva)
• Actualización del gráfico de Helm(El enlace se abre en una ventana nueva)