Generate a Mission Control support bundle

You can generate a Mission Control support bundle to assist with troubleshooting issues. The system automatically redacts sensitive information from your support bundle, such as passwords and tokens using built-in redactors. After you download a support bundle, you can share it with DataStax Support for troubleshooting assistance.

For KOTS-based installations, you can use the included KOTS Admin Console to analyze Mission Control issues and review suggested remediation.

For Helm and KOTS installations, you can use the CLI to generate a support bundle. You can download a support bundle and send it to DataStax Support for troubleshooting assistance.

Create a support bundle

KOTS Admin Console
Command Line Interface (CLI)

For KOTS-based installations, you can use the KOTS Admin Console to create a support bundle.

In the KOTS Admin Console, select the Troubleshoot tab.
Click Analyze to start analyzing Mission Control.

Mission Control uses the support bundle plugin to analyze your Mission Control installation and produce a support bundle.

No data leaves the cluster. Mission Control generates support bundles internally within your environment. The system never sends data across the internet or to anyone else.

After the analysis is complete, the Support bundle analysis section displays the detected issues and suggested remediation. For more information, see Support bundle analysis.
Review the detected issues and suggested remediation.
To download the support bundle, click Download bundle.

You can use these instructions for both Helm and KOTS installations.

Create a support bundle using one of the following methods, depending on your environment:

Default kots.io spec
Air gap
Mission Control installed
Mission Control not installed

If you use the default kots.io specification, run the following command to create a support bundle:

kubectl support-bundle https://kots.io

If you are on an air-gapped server, do the following:

On a computer with internet access, run the following command to download the default kots.io specification:
```
curl -o spec.yaml https://kots.io -H 'User-agent:Replicated_Troubleshoot/v1beta1'
```
Upload the spec.yaml file to the air-gapped server.
Create a support bundle using the uploaded spec.yaml file:
```
kubectl support-bundle LOCATION/spec.yaml
```
Replace LOCATION with the path to the spec.yaml file.

If the Admin Console is running and you have installed Mission Control, then run the following command to create a support bundle.

This bundle includes any customizations specific to Mission Control from the support-bundle.yaml manifest file.

kubectl support-bundle http://SERVER_ADDRESS:8800/api/v1/troubleshoot/mission-control

Replace SERVER_ADDRESS with the address of the Admin Console.

If you have not installed Mission Control but the Admin Console is running, then run the following command to create a support bundle.

This bundle includes customizations from the Admin Console.

kubectl support-bundle http://SERVER_ADDRESS:8800/api/v1/troubleshoot

Replace SERVER_ADDRESS with the address of the Admin Console.

The support bundle generates and saves to your local machine. The command line displays the location of the support bundle.

Result

Support bundle analysis results saved to
Users/username/support-bundle-resources/support-bundle-**YYYY-MM-DD**.tar.gz

Move the support bundle to a secure location:

mv support-bundle-YYYY-MM-DD.tar.gz TARGET_LOCATION

Replace TARGET_LOCATION with the path to your target location, for example, Downloads.

Support bundle analysis

For KOTS-based installations, you can use the KOTS Admin Console to analyze Mission Control issues and review suggested remediation. The Support bundle analysis section displays the detected issues and suggested remediation. The system bases the analysis on the collected data in the support bundle. The analysis section shows three tabs:

Analysis insights: Displays the detected issues and suggested remediation.
File inspector: Displays the collected files in the support bundle in JSON format.
Redactor report: Displays the redacted information in the support bundle.

Generate a host support bundle

For Kubernetes installer provisioned clusters, also known as embedded clusters, you can generate a host support bundle to assist with troubleshooting a cluster that is down. DataStax provides you with a host support bundle YAML file that you run with a command to generate the host support bundle.

Typically, you don’t need root access to run the host collectors and analyzers. However, depending on what the collector collects, you might need to run the support-bundle binary with elevated permissions. For example, if you run the filesystemPerformance host collector against /var/lib/etcd and the user running the binary does not have permissions on this directory, the collection process fails.

To generate a host support bundle, do the following:

Install the support-bundle plugin.
Save the host support bundle YAML file from DataStax on the host. For air gap environments, download the file and copy it to the air gap machine.
Run the following command on the host to generate a host support bundle:
```
./support-bundle --interactive=false LOCATION/FILENAME.yaml
```
Replace the following:
- LOCATION: The path to the host support bundle YAML file
- FILENAME: The name of the host support bundle YAML file from DataStax
Share the host support bundle with DataStax support.
Repeat these steps for each node because you cannot generate host support bundles on remote hosts. If you have a multi-node Kubernetes cluster, then you must run the support-bundle binary on each node and generate a host support bundle for each node.

Diagnostic collector

Use the open source diagnostic collector for Apache Cassandra® to collect diagnostic information from your Mission Control environment.

The diagnostic collector collects diagnostic support bundles from each node in your Mission Control cluster.

For complete diagnostic collector documentation, see the DataStax GitHub repository. For troubleshooting information, see Troubleshooting.

Prerequisites

Makefile
A running Mission Control cluster with healthy pods
kubectl configured with access to your cluster
Proper permissions to access pods in the target namespace

Download the collector

Download the latest collector release from the DataStax GitHub repository.

Generate support diagnostics for a Mission Control cluster

Set your cluster details:
```
export CLUSTER_NAME="CLUSTER_NAME"
```
Replace CLUSTER_NAME with the Mission Control cluster name.
Navigate to the extracted collector directory:
```
cd ds-collector
```
Find the correct pod name and namespace:
```
# Find all pods across all namespaces
kubectl get pods -A | grep -i cassandra

# Or search in a specific namespace
kubectl get pods -n POD_NAMESPACE | grep -i cassandra

# Verify the pod exists and get its full details
kubectl get pod POD_NAME -n POD_NAMESPACE -o wide
```
Look for a pod with status `Running and note both the pod name and namespace.

The pod must be in Running status for the diagnostic collector to work properly. If the pod shows Init:ImagePullBackOff or other error states, resolve the pod issues before proceeding.
Configure the collector for Kubernetes mode:
1. Create a working configuration file:
  cp collector.conf.in collector.conf
  The collector.conf.in file is a template. Copy the template and modify it for your environment to create a collector.conf file.
2. Enable Kubernetes mode:
  sed -i.bak 's/#use_k8s="true"/use_k8s="true"/' collector.conf
3. Update the namespace and enable sudo:
  sed -i.bak 's/#k8s_namespace="default"/k8s_namespace="POD_NAMESPACE"/' collector.conf sed -i.bak 's/#skipSudo="true"/skipSudo="true"/' collector.conf
  Replace POD_NAMESPACE with the actual namespace where your pod runs from the previous step.
  
  The k8s_namespace setting in collector.conf must match the actual namespace where your pod runs.
Verify the configuration and generate the support bundle:
```
# Test the configuration
./ds-collector -T -f collector.conf -n POD_NAME

# Generate the support bundle
./ds-collector -X -f collector.conf -n POD_NAME
```
Replace POD_NAME with the pod name from step 3.

The collector does the following:
- Connects to your Mission Control cluster using kubectl.
- Collects diagnostic information from all nodes in the cluster.
- Generates a support bundle in the current directory.
- Names the bundle with a timestamp and your cluster name.
Verify the support bundle creation.

The collector creates diagnostic artifacts in the current directory or the configured base directory. The default is /tmp/datastax.
Result
result of datastax_collector from **POD_NAME** processing artifact **ARTIFACT_NAME**.tar.gz
The collector names the artifacts with timestamps and cluster information, following the pattern artifacts.tar.gz.
Share the generated support bundle with DataStax support for assistance.