Risoluzione dei problemi relativi ai cluster del carico di lavoro con Diagnostica arresti anomali

Questo argomento illustra come utilizzare Diagnostica arresti anomali cluster (Crashd) per diagnosticare cluster del carico di lavoro instabili o che non rispondono in base a Photon OS in Tanzu Kubernetes Grid con un cluster di gestione autonomo.

Per informazioni su come utilizzare Crashd per diagnosticare i cluster del carico di lavoro distribuiti da un supervisore vSphere with Tanzu, vedere How to collect a diagnostic log bundle from a Tanzu Kubernetes Guest Cluster on vSphere with Tanzu nella Knowledge Base di VMware.

Panoramica: Crashd

Crashd esamina il cluster del carico di lavoro di bootstrap che il processo tanzu cluster create crea localmente usando kind prima di distribuire il cluster sull'infrastruttura cloud.

Crashd è un progetto open source che semplifica la risoluzione dei problemi relativi ai cluster Kubernetes.

Crashd utilizza un file di script scritto in Starlark, un linguaggio simile a Python, che interagisce con i cluster di gestione o del carico di lavoro per raccogliere informazioni su infrastruttura e cluster.

Crashd può raccogliere i dati di diagnostica dalle infrastrutture supportate, tra cui:

• AWS
• Azure
• vSphere

Crashd acquisisce l'output dai comandi eseguiti dallo script e aggiunge l'output a un file tar. Il file tar viene quindi salvato in locale per ulteriori analisi.

Tanzu Kubernetes Grid include file binari firmati per Crashd e un file di script di diagnostica per i cluster del carico di lavoro di Photon OS.

Installare o aggiornare il file binario Crashd

Per installare o aggiornare crashd, attenersi alle istruzioni seguenti.

1. Passare alla pagina di download di Tanzu Kubernetes Grid e accedere con le credenziali di VMware Customer Connect.

2. Scaricare Crashd per la piattaforma in uso.

   • Linux: crashd-linux-amd64-v0.3.7+vmware.7-4-g59b239d.tar.gz
   • macOS: crashd-darwin-amd64-v0.3.7+vmware.7-4-g59b239d.tar.gz

3. Utilizzare il comando tar per decomprimere il file binario per la piattaforma in uso.

   • Linux:

     tar -xvf crashd-linux-amd64-v0.3.7-vmware.7.tar.gz
     

   • macOS:

     tar -xvf crashd-darwin-amd64-v0.3.7-vmware.7.tar.gz
     

4. Il passaggio precedente crea una directory denominata crashd con i seguenti file:

   crashd
   crashd/args
   crashd/diagnostics.crsh
   crashd/crashd-PLATFORM-amd64-v0.3.7+vmware.7
   

5. Spostare il file binario nella cartella /usr/local/bin.

   • Linux:

     mv ./crashd/crashd-linux-amd64-v0.3.7+vmware.7 /usr/local/bin/crashd
     

   • macOS:

     mv ./crashd/crashd-darwin-amd64-v0.3.7+vmware.7 /usr/local/bin/crashd
     

Esecuzione di Crashd nei cluster del carico di lavoro di Photon OS

Quando Crashd viene eseguito, acquisisce i valori degli argomenti da un file args e li passa a un file di script, diagnostics.crsh. Lo script esegue i comandi per estrarre informazioni che possono essere utili per diagnosticare i problemi relativi ai cluster del carico di lavoro di Photon OS.

Prerequisiti

Prima di eseguire lo script Crashd diagnostics.crsh, è necessario che sulla macchina locale siano disponibili i programmi seguenti sul relativo percorso di esecuzione:

• kubectl
• scp

• ssh

  Nota

  durante l'analisi di problemi con un cluster di bootstrap, il comando kind (v0.7.0 o versione successiva) dovrà essere installato localmente.

Inoltre, prima di poter eseguire Crashd, è necessario eseguire i passaggi seguenti:

• Configurare Crashd con una coppia di chiavi private/pubbliche SSH.
• Assicurarsi che le macchine virtuali Tanzu Kubernetes Grid siano configurate per utilizzare la chiave pubblica SSH.
• Estrarre il file kubeconfig per il cluster di gestione utilizzando il comando tanzu mc kubeconfig get <management-cluster-name>.
• Per una configurazione più semplice, verificare che kubeconfig, il file public-key, il file diagnostics.crsh e il file args si trovino nella stessa posizione.

• Eliminare qualsiasi cluster kind locale diverso da quello creato per distribuire il cluster del carico di lavoro per cui si sta eseguendo la risoluzione dei problemi:

  • Eseguire docker ps per identificare il cluster kind attualmente in esecuzione
  • Eliminare tutti gli altri cluster kind eseguendo kind delete cluster --name CLUSTER-NAME

Configurare Crashd

1. Andare alla posizione in cui il bundle Crashd è stato scaricato e decompresso.

2. In un editor di testo, sovrascrivere il file degli argomenti esistente args con il codice seguente. Questo file contiene le coppie chiave/valore da passare allo script CrashD:

   # ######################################################
   # Crashd script argument file
   #
   # This file defines CLI argument values that are passed
   # Crashd when running scripts for troubleshooting TKG
   # clusters.
   # ######################################################
   
   # target: specifies cluster to target.
   # Valid targets are: {bootstrap, mgmt, workload}
   target=mgmt
   
   # infra: the underlying infrastructure used by the TKG cluster.
   # Valid values are: {vsphere, aws, azure}
   infra=vsphere
   
   # workdir: a local directory where collected files are staged.
   workdir=./workdir
   
   # ssh_user: the user ID used for SSH connections to cluster nodes.
   ssh_user=capv
   
   # ssh_pk_file: the path to the private key file created to SSH
   # into cluster nodes.
   ssh_pk_file=./capv.pem
   
   # ######################################################
   # Management Cluster
   # The following arguments are used to collect information
   # from a management cluster or named workload clusters.
   # ######################################################
   
   # mgmt_cluster_config: the kubeconfig file path for the management cluster.
   mgmt_cluster_config=./tkg_cluster_config
   
   # ######################################################
   # Workload Cluster
   # The following arguments are used to collect information
   # from one or more workload clusters that are managed
   # by the management cluster configured above.
   # ######################################################
   
   # workload_clusters: a comma separated list of workload cluster names
   # [uncomment below]
   #workload_clusters=tkg-cluster-wc-498
   
   # workload_cluster_ns: the namespace where the workload cluster
   # is hosted in the management plane.
   # Note: it's actually the namespace in which the secrets/${workload_cluster_name}-kubeconfig
   # is created in the management cluster.
   # [uncomment below]
   #workload_cluster_ns=default
   

3. Registrare il percorso locale a un file di chiave privata SSH. Se non si dispone già di una coppia di chiavi SSH o si desidera generarne una nuova, eseguire ssh-keygen come descritto in Creazione di una coppia di chiavi SSH. Ad esempio:

   ssh-keygen -t rsa -b 4096 -C "[email protected]"

   Quando richiesto, immettere un percorso locale per la posizione del file. Per informazioni sulla creazione delle coppie di chiavi SSH.

4. Nel file args, specificare i seguenti argomenti:

   • target: Impostare questo valore su:
     • bootstrap per diagnosticare un cluster di gestione autonomo di bootstrap locale
     • mgmt per diagnosticare un cluster di gestione autonomo distribuito
     • workload per diagnosticare uno o più cluster del carico di lavoro
   • infra: L'infrastruttura sottostante per il cluster: aws, azure o vsphere.
   • workdir: posizione in cui vengono raccolti i file.
   • ssh_user: L'utente SSH utilizzato per accedere alle macchine del cluster. Per i cluster in esecuzione in vSphere, il nome utente è capv.
   • ssh_pk_file: il percorso al file della chiave privata SSH.
   • mgmt_cluster_config Il percorso del file kubeconfig per il cluster di gestione.

5. Per diagnosticare i cluster del carico di lavoro, rimuovere il commento e impostare quanto segue oltre agli argomenti elencati sopra:

   • workload_clusters: un elenco separato da virgole dei nomi dei cluster dei carichi di lavoro da cui raccogliere informazioni di diagnostica.
   • workload_cluster_ns: Lo spazio dei nomi in cui secrets/WORKLOAD-CLUSTER-NAME-kubeconfig viene creato nel cluster di gestione.

Eseguire Crashd

1. Creare un file di script Crashd diagnostics.crsh contenente il codice nel file di diagnostica diagnostics.crsh disponibile di seguito.

2. Eseguire il comando crashd dalla posizione in cui si trovano il file di script diagnostics.crsh e il file degli argomenti args.

   crashd run --args-file args diagnostics.crsh
   

3. Facoltativamente, monitorare l'output di Crashd. Per impostazione predefinita, il comando crashd viene eseguito in modalità invisibile all'utente fino al completamento. Tuttavia, è possibile utilizzare il flag --debug per visualizzare sullo schermo messaggi del registro simili al seguente:

   crashd run --debug --args-file args diagnostics.crsh
   
   DEBU[0003] creating working directory ./workdir/tkg-kind-12345
   DEBU[0003] kube_capture(what=objects)
   DEBU[0003] Searching in 20 groups
   ...
   DEBU[0015] Archiving [./workdir/tkg-kind-12345] in bootstrap.tkg-kind-12345.diagnostics.tar.gz
   DEBU[0015] Archived workdir/tkg-kind-12345/kind-logs/docker-info.txt
   DEBU[0015] Archived workdir/tkg-kind-12345/kind-logs/tkg-kind-12345-control-plane/alternatives.log
   DEBU[0015] Archived workdir/tkg-kind-12345/kind-logs/tkg-kind-12345-control-plane/containerd.log
   

File di diagnostica diagnostics.crsh

Nel bundle CrashD, scaricare e sovrascrivere il file diagnostics.crsh esistente con il codice seguente, come script da trasmettere al comando crashd run:

def capture_node_diagnostics(nodes):
    capture(cmd="sudo df -i", resources=nodes)
    capture(cmd="sudo crictl info", resources=nodes)
    capture(cmd="df -h /var/lib/containerd", resources=nodes)
    capture(cmd="sudo systemctl status kubelet", resources=nodes)
    capture(cmd="sudo systemctl status containerd", resources=nodes)
    capture(cmd="sudo journalctl -xeu kubelet", resources=nodes)
    capture(cmd="sudo journalctl -xeu containerd", resources=nodes)
    capture(cmd="sudo cat /var/log/cloud-init-output.log", resources=nodes)
    capture(cmd="sudo cat /var/log/cloud-init.log", resources=nodes)
def capture_windows_node_diagnostics(nodes):
    capture(cmd="Get-CimInstance -ClassName Win32_LogicalDisk", file_name="disk_info.out", resources=nodes)
    capture(cmd="(Get-ItemProperty -Path c:\\windows\\system32\\hal.dll).VersionInfo.FileVersion",file_name="windows_version_info.out", resources=nodes)
    capture(cmd="cat C:\\k\\StartKubelet.ps1 ; cat C:\\var\\lib\\kubelet\\kubeadm-flags.env", resources=nodes)
    capture(cmd="Get-Service Kubelet | select * ", resources=nodes)
    capture(cmd="Get-Service Containerd | select * ", resources=nodes)
    capture(cmd="Get-Service ovs* | select * ", resources=nodes)
    capture(cmd="Get-Service antrea-agent | select * ", resources=nodes)
    capture(cmd="Get-Service kube-proxy | select * ", resources=nodes)
    capture(cmd="Get-Service Kubelet | select * ", resources=nodes)
    capture(cmd="Get-HNSNetwork", resources=nodes)
    capture(cmd="& 'c:\\Program Files\\containerd\\crictl.exe' -r 'npipe:////./pipe/containerd-containerd' info", resources=nodes)
    capture(cmd="Get-MpPreference | select ExclusionProcess", resources=nodes)
    capture(cmd="cat c:\\var\\log\\kubelet\\kubelet.exe.INFO", resources=nodes)
    capture(cmd="cat c:\\var\\log\\antrea\\antrea-agent.exe.INFO", resources=nodes)
    capture(cmd="cat c:\\var\\log\\kube-proxy\\kube-proxy.exe.INFO", resources=nodes)
    capture(cmd="cat 'c:\\Program Files\\Cloudbase Solutions\\Cloudbase-Init\\log\\cloudbase-init-unattend.log'", resources=nodes)
    capture(cmd="cat 'c:\\Program Files\\Cloudbase Solutions\\Cloudbase-Init\\log\\cloudbase-init.log'", resources=nodes)
    copy_from(path="C:\\Windows\\System32\\Winevt\\Logs\\System.evtx", resources=nodes)
    copy_from(path="C:\\Windows\\System32\\Winevt\\Logs\\Application.evtx", resources=nodes)
    copy_from(path="c:\\openvswitch\\var\\log\\openvswitch\\ovs-vswitchd.log", resources=nodes)
    copy_from(path="c:\\openvswitch\\var\\log\\openvswitch\\ovsdb-server.log", resources=nodes)
# fetches a suitable capi provider, for either capa or others (capv/capz),
# to be used for enumerating cluster machines
def fetch_provider(iaas, workload_cluster_name, ssh_cfg, kube_cfg, namespace, filter_labels):
    # workaround: vsphere and azure use same provider as they work similarly (see issue #162)
    if iaas == "vsphere" or iaas == "azure":
        provider = capv_provider(
            workload_cluster=workload_cluster_name,
            namespace=namespace,
            ssh_config=ssh_cfg,
            mgmt_kube_config=kube_cfg,
            labels=filter_labels
        )
    else:
        provider = capa_provider(
            workload_cluster=workload_cluster_name,
            namespace=namespace,
            ssh_config=ssh_cfg,
            mgmt_kube_config=kube_cfg,
            labels=filter_labels
        )
    return provider
# retrieves linux management provider for linux nodes
def fetch_mgmt_provider_linux(infra, ssh_cfg, kube_cfg, ns):
    return fetch_provider(infra, '', ssh_cfg, kube_cfg, ns, ["kubernetes.io/os=linux"])
# retrieves windows mgmt provider for windows nodes
def fetch_mgmt_provider_windows(infra, ssh_cfg, kube_cfg, ns):
    return fetch_provider(infra, '', ssh_cfg, kube_cfg, ns, ["kubernetes.io/os=windows"])
# retrieves linux workload provider for linux nodes
def fetch_workload_provider_linux(infra, wc_cluster, ssh_cfg, kube_cfg, ns):
    return fetch_provider(infra, wc_cluster, ssh_cfg, kube_cfg, ns, ["kubernetes.io/os=linux"])
# retrieves windows workload provider for windodws nodes
def fetch_workload_provider_windows(infra, wc_cluster, ssh_cfg, kube_cfg, ns):
    return fetch_provider(infra, wc_cluster, ssh_cfg, kube_cfg, ns, ["kubernetes.io/os=windows"])
def diagnose_mgmt_cluster(infra):
    # validation
    args.ssh_user
    args.ssh_pk_file
    args.mgmt_cluster_config
    if len(infra) == 0:
        print("Infra argument not provided")
        return
    wd = "{}/tkg-mgmt-cluster".format(args.workdir)
    conf = crashd_config(workdir=wd)
    ssh_conf = ssh_config(username=args.ssh_user, private_key_path=args.ssh_pk_file)
    kube_conf = kube_config(path=args.mgmt_cluster_config)
    # fetch linux mgmt node diagnostics
    mgmt_provider_linux = fetch_mgmt_provider_linux(infra, ssh_conf, kube_conf, '')
    lin_nodes = resources(provider=mgmt_provider_linux)
    capture_node_diagnostics(lin_nodes)
    # fetch win mgmt node diagnostics
    mgmt_provider_win = fetch_mgmt_provider_windows(infra, ssh_conf, kube_conf, '')
    win_nodes = resources(provider=mgmt_provider_win)
    if len(win_nodes) > 0:
        capture_windows_node_diagnostics(win_nodes)
    #add code to collect pod info from cluster
    set_defaults(kube_config(capi_provider = mgmt_provider_linux))
    pods_ns=[
        "capi-kubeadm-bootstrap-system",
        "capi-kubeadm-control-plane-system",
        "capi-system",
        "capi-webhook-system",
        "cert-manager",
        "tkg-system",
        "kube-system",
        "tkr-system",
        "capa-system",
        "capv-system",
        "capz-system",
    ]
    if infra == "vsphere":
        pods_ns.append("tkg-system-networking")
        pods_ns.append("avi-system")
    kube_capture(what="logs", namespaces=pods_ns)
    kube_capture(what="objects", kinds=["pods", "services"], namespaces=pods_ns)
    kube_capture(what="objects", kinds=["deployments", "replicasets"], groups=["apps"], namespaces=pods_ns)
    kube_capture(what="objects", kinds=["apps"], groups=["kappctrl.k14s.io"], namespaces=["tkg-system"])
    kube_capture(what="objects", kinds=["tanzukubernetesreleases"], groups=["run.tanzu.vmware.com"])
    kube_capture(what="objects", kinds=["configmaps"], namespaces=["tkr-system"])
    kube_capture(what="objects", categories=["cluster-api"])
    kube_capture(what="objects", groups=["ipam.cluster.x-k8s.io"])
    if infra == "vsphere":
        kube_capture(what="objects", kinds=["akodeploymentconfigs"])
    archive(output_file="tkg-mgmt.diagnostics.tar.gz", source_paths=[conf.workdir])
def diagnose_workload_cluster(infra, name):
    # validation
    args.infra
    args.ssh_user
    args.ssh_pk_file
    args.mgmt_cluster_config
    workload_ns = args.workload_cluster_ns
    if len(infra) == 0:
        print("Infra argument not provided")
        return
    wd = "{}/{}".format(args.workdir, name)
    conf = crashd_config(workdir=wd)
    ssh_conf = ssh_config(username=args.ssh_user, private_key_path=args.ssh_pk_file)
    kube_conf = kube_config(path=args.mgmt_cluster_config)
    # fetch linux workload node diagnostics
    wc_provider_linux = fetch_workload_provider_linux(infra, name, ssh_conf, kube_conf, workload_ns)
    lin_nodes = resources(provider=wc_provider_linux)
    capture_node_diagnostics(lin_nodes)
    # fetch win workload node diagnostics
    wc_provider_win = fetch_workload_provider_windows(infra, name, ssh_conf, kube_conf, workload_ns)
    win_nodes = resources(provider=wc_provider_win)
    if len(win_nodes) > 0:
        capture_windows_node_diagnostics(win_nodes)
    #add code to collect pod info from cluster
    set_defaults(kube_config(capi_provider = wc_provider_linux))
    pods_ns=["default", "kube-system", "tkg-system"]
    if infra == "vsphere":
        pods_ns.append("tkg-system-networking")
        pods_ns.append("avi-system")
    kube_capture(what="logs", namespaces=pods_ns)
    kube_capture(what="objects", kinds=["pods", "services"], namespaces=pods_ns)
    kube_capture(what="objects", kinds=["deployments", "replicasets"], groups=["apps"], namespaces=pods_ns)
    kube_capture(what="objects", kinds=["apps"], groups=["kappctrl.k14s.io"], namespaces=["tkg-system"])
    if infra == "vsphere":
        kube_capture(what="objects", kinds=["akodeploymentconfigs"])
    archive(output_file="{}.diagnostics.tar.gz".format(name), source_paths=[conf.workdir])
# extract diagnostic info from local kind boostrap cluster
def diagnose_bootstrap_cluster():
    p = prog_avail_local("kind")
    if p == "":
        print("Error: kind is not available")
        return
    clusters=get_tkg_bootstrap_clusters()
    if len(clusters) == 0:
        print("No tkg-kind bootstrap cluster found")
        return
    pod_ns=[
        "caip-in-cluster-system",
        "capi-kubeadm-bootstrap-system",
        "capi-kubeadm-control-plane-system",
        "capi-system",
        "capi-webhook-system",
        "capv-system",
        "capa-system",
        "capz-system",
        "cert-manager",
        "tkg-system",
        "tkg-system-networking",
        "avi-system",
    ]
    # for each tkg-kind cluster:
    #  - capture kind logs, export kubecfg, and api objects
    for kind_cluster in clusters:
        wd = "{}/{}".format(args.workdir, kind_cluster)
        run_local("kind export logs --name {} {}/kind-logs".format(kind_cluster, wd))
        kind_cfg = capture_local(
            cmd="kind get kubeconfig --name {0}".format(kind_cluster),
            workdir="./",
            file_name="{}.kubecfg".format(kind_cluster)
        )

        conf = crashd_config(workdir=wd)
        set_defaults(kube_config(path=kind_cfg))
        kube_capture(what="objects", kinds=["pods", "services"], namespaces=pod_ns)
        kube_capture(what="objects", kinds=["deployments", "replicasets"], groups=["apps"], namespaces=pod_ns)
        kube_capture(what="objects", categories=["cluster-api"])
        kube_capture(what="objects", kinds=["akodeploymentconfigs"])
        archive(output_file="bootstrap.{}.diagnostics.tar.gz".format(kind_cluster), source_paths=[conf.workdir])
# return tkg clusters in kind (tkg-kind-xxxx)
def get_tkg_bootstrap_clusters():
    clusters = run_local("kind get clusters").split('\n')
    result = []
    for cluster in clusters:
        if cluster.startswith("tkg-kind"):
            result.append(cluster)

    return result
def check_prereqs():
    # validate args
    args.workdir
    p = prog_avail_local("ssh")
    if p == "":
        print("Error: ssh is not available")
        return False

    p = prog_avail_local("scp")
    if p == "":
        print("Error: scp is not available")
        return False

    p = prog_avail_local("kubectl")
    if p == "":
        print("Error: kubectl is not available")
        return False

    return True

def diagnose(target, infra):
    # validation
    if not check_prereqs():
        print("Error: One or more prerequisites are missing")
        return
    # run diagnostics
    if target == "bootstrap":
        diagnose_bootstrap_cluster()
    elif target == "mgmt":
        diagnose_mgmt_cluster(infra)
    elif target == "workload":
        for name in args.workload_clusters.split(","):
            diagnose_workload_cluster(infra, name)
    else:
        print("Error: unknown target {}".format(target))
diagnose(args.target, args.infra)