Importante: questa documentazione presuppone la conoscenza di Helm e delle carte Helm e non intende fornire esempi dettagliati e prescrittivi. È destinata ai clienti che hanno familiarità sia con Tableau Server che con Helm e le carte Helm.

Questo argomento illustra le fasi generali della distribuzione di Tableau Server su Kubernetes mediante una carta Helm.

Prerequisiti

Prima di iniziare, assicurati di soddisfare i prerequisiti. Per maggiori informazioni, consulta Carta Helm di Tableau Server - Prerequisiti.

Panoramica rapida della distribuzione di Tableau Server tramite una carta Helm

Importante: questa è una descrizione di base e generale della distribuzione di Tableau Server mediante carte Helm. Non intende descrivere una procedura completa. Presuppone la conoscenza di Helm e delle carte Helm.

Prima di iniziare, verifica di soddisfare i prerequisiti per la distribuzione di Tableau Server mediante carte Helm. Per i dettagli, consulta Carta Helm di Tableau Server - Prerequisiti.

Distribuire Tableau Server a nodo singolo

Distribuisci un’istanza a nodo singolo di Tableau Server eseguendo questi comandi in un prompt (sostituisci <namespace> con lo spazio dei nomi della tua versione, ad esempio tableau o default):

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

Distribuire Tableau Server multi-nodo

Distribuisci un’istanza multi-nodo di Tableau Server eseguendo questi comandi in un prompt, utilizzando la stessa convenzione per lo spazio dei nomi di cui sopra:

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

Runbook multi-nodo EKS (spazio dei nomi + PV di bootstrap statico)

Questa sezione descrive l’ordine delle operazioni per EKS: spazio dei nomi dedicato, componente aggiuntivo CSI EFS, IAM per il ruolo del nodo, PV di bootstrap statico e Helm.

1. Crea uno spazio dei nomi dedicato.

   Deve corrispondere a claimFef.namespace nel PV di bootstrap. Questo esempio utilizza tableau.

   kubectl create namespace tableau-server
   kubectl get namespace tableau

2. Verifica che il componente aggiuntivo CSI EFS esista.

   Se il componente aggiuntivo non è presente, crealo e attendi che lo stato diventi 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. Conferma la Storageclass:

   Storage class efs-bootstrap: applica se non è già presente. Per i dettagli, consulta Prerequisiti di Amazon Elastic Kubernetes Service (EKS).

   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. Conferma il valore PV di bootstrap statico.

   claimRef deve fare riferimento allo stesso spazio dei nomi e allo stesso nome PVC creato dalla carta Helm (tableau-server-bootstrap). Sostituisci fs-... con l’ID del tuo file system 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 nel ruolo dell’istanza del nodo.

   Collega il client EFS e i criteri di sola lettura EC2. Vedi Prerequisiti di Amazon Elastic Kubernetes Service (EKS) per la risoluzione di <your-node-instance-role> dal gruppo di nodi.

   Storage class efs-bootstrap: applica se non è già presente. Per i dettagli, consulta Prerequisiti di Amazon Elastic Kubernetes Service (EKS).

   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. Valori

   In values-multinode.yaml (o una sovrapposizione), imposta la modalità PV statica manuale

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

7. Assicurati che image.repository, image.tage i segreti e la licenza siano impostati come richiesto.

8. Installa la carta Helm

   Installa la carta nello stesso spazio dei nomi del PV claimRef:

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

9. Verifica l’archiviazione e i pod:

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

10. Stato PVC dei dati

    Lo stato delle PVC dei dati potrebbe comparire brevemente come Pending finché i volumi EBS non si collegano. Tutte le PVC devono passare allo stato Bound, quindi a Runninge infine a READY 1/1.

11. Topologia (facoltativa)

    Se l’hook di post-installazione è disabilitato, potresti aver bisogno di impostare il nodo clustercontroller e di applicare le modifiche in sospeso (consulta Automazione della topologia post-installazione (hook) più avanti in questo documento). Quando sono presenti più nodi Tableau, il comando tsm pending-changes apply può generare avvisi sulla distribuzione del server di indicizzazione e ricerca o sull’insieme dei servizi di coordinamento. Gestisci questi avvisi come documentato in Server di indicizzazione e ricerca e Servizio di coordinamento di Tableau Server.

Installazione personalizzata

1. Personalizza i valori

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

2. Installa con valori personalizzati

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

Configurazione

Modalità di distribuzione

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

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

Allineamento della topologia: values-multinode.yaml viene fornito con una topologia config.configJson di esempio (ID nodo come node1, node2, node3). Se modifichi worker.replicaCount o riorganizzi i servizi, aggiorna la topologia (ed eventuali assegnazioni di processi di Tableau correlati) in modo che il numero e i ruoli dei nodi TSM corrispondano alla distribuzione. Consulta la Guida di Tableau Server per il clustering e il layout dei processi.

Opzioni di configurazione chiave

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

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

In alternativa, puoi impostarli utilizzando le variabili di ambiente:

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

È consigliabile utilizzare un file separato (ad esempio, secrets.yaml) e passarlo con lo switch -f.

secrets.yaml:

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

Esempio di installazione/aggiornamento 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: il riferimento a un segreto Kubernetes preesistente (ad esempio secrets.existingSecret) non è attualmente supportato. L’unico metodo supportato è l’utilizzo dei valori della carta con un file di valori segreto separato.

# 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'

Archiviazione 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

Per i cluster che utilizzano CSI EFS statica (ad esempio con mounttargetip), Helm può gestire sia PV che PVC di bootstrap:

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 aggiunge un contenitore di inizializzazione che chown/chmods /docker/config/bootstrap in modo che il processo Tableau (UID/GID 999:998) possa scrivere bootstrap.json sui montaggi EFS condivisi che per impostazione predefinita utilizzano root:root.

Quando createPV: true, la carta crea il valore PV di bootstrap da valori (ad esempio tableau-bootstrap-pv) ed esegue il binding delle PVC tableau-server-bootstrap a questo valore.

Se gestisci manualmente i PV di bootstrap, crea tableau-bootstrap-pv , quindi installa Helm con createPV: false e 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

Limiti delle risorse

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

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

Configurazione del servizio

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 di installazione ingress (esempio: controller ingress NGINX)

1. Installa un controller ingress nel cluster (necessario per abilitare l’ingresso per la carta).

2. Imposta i valori di ingress nel file dei valori:

   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. Crea un record DNS che punta a tableau.example.com all’endpoint bilanciamento di ingresso/bilanciamento.

4. Crea un segreto TLS (o utilizza cert-manager) nello spazio dei nomi della versione.

5. Distribuisci/aggiorna la carta e verifica l’ingresso:

   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

Per maggiori informazioni, consulta:

• Concetto Ingress in Kubernetes (in inglese)(Il collegamento viene aperto in una nuova finestra)

• Guida alla distribuzione di ingress-nginx (in inglese)(Il collegamento viene aperto in una nuova finestra)

• Primi passi in cert-manager (in inglese)(Il collegamento viene aperto in una nuova finestra)

Controlli di integrità

La carta supporta le sonde di avvio, di attività e di preparazione. La sonda di avvio consente una prima inizializzazione estesa (ad esempio, failureThreshold: 200 × periodSeconds) prima dell’esecuzione di attività/preparazione:

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

Per i pod worker multi-nodo, la carta utilizza come valore predefinito worker.healthChecks.enabled: false per evitare falsi errori della sonda quando i worker eseguono insiemi di processi limitati (ad esempio, solo agente amministrazione + controller cluster).

Utilizzo

# 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

Aggiornamento

Aggiornare la carta Helm di Tableau Server

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

Aggiornare con nuovi valori

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

Automazione della topologia post-installazione (hook)

Per le installazioni multi-nodo, questa carta può eseguire un processo hook post-installazione/post-aggiornamento che:

• attende la registrazione dei nodi di lavoro in TSM

• imposta l’assegnazione del processo clustercontroller ai worker

• esegue tsm pending-changes apply -iw --ignore-prompt quando le modifiche sono in sospeso

Configurazione:

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

Impostazioni predefinite:

• disabilitato in values.yaml

• in values-multinode.yaml, seleziona hooks.autoApplyWorkerTopology.enabled (può essere true o false a seconda della versione; abilita per la configurazione automatica di clustercontroller dei worker)

Verifica l’esecuzione dell’hook:

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 manuale se l’hook è disabilitato o non riesce: esegui tsm topology set-process per ogni nodo TSM di lavoro (in genere da nodo2 a nodo(1+N) quando sono presenti N worker; conferma gli 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: usa -iw per tsm pending-changes apply. L’opzione -ig non è valida in questo ambiente.

Disinstallazione

helm uninstall tableau-server

Avviso: verranno eliminate tutte le risorse, inclusi i volumi persistenti. Assicurati di eseguire il backup dei dati prima della disinstallazione.

Fasi di convalida

Prima del rilascio o quando modifichi la carta, esegui:

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. Template (prova):

   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. Test di installazione (facoltativo):

   1. In uno spazio dei nomi di test, esegui helm install con values-single o values-multinode.

   2. Esegui kubectl rollout status (per StatefulSet, attendi che il pod sia pronto) e i controlli di sicurezza di base (ad es tsm status o HTTP per il servizio).

Per informazioni dettagliate sulla risoluzione dei problemi, consulta Carta Helm di Tableau Server - Risoluzione dei problemi.

Risorse aggiuntive

• Documentazione di Tableau Server(Il collegamento viene aperto in una nuova finestra)
• Documentazione di Helm(Il collegamento viene aperto in una nuova finestra)
• Aggiornamento della carta Helm (in inglese)(Il collegamento viene aperto in una nuova finestra)