> For the complete documentation index, see [llms.txt](https://developer.harness.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.harness.io/harness-platform/troubleshooting-and-resources/tutorials/install-delegate.md).

# Installing the Harness Delegate

The [Harness Delegate](/harness-platform/use-harness-platform/delegates/delegate/delegate-concepts/delegate-overview.md) is a lightweight worker process that is installed on your infrastructure and communicates only via outbound HTTP/HTTPS to the Harness Platform. This enables the Harness Platform to leverage the delegate to execute the CI/CD and other tasks on your behalf, without any of your secrets leaving your network.

You can install the Harness Delegate on either Docker or Kubernetes.

{% hint style="info" %}
**NOTE**

You might need additional permissions to execute commands in delegate scripts and create Harness users.
{% endhint %}

### Install the default Harness Delegate <a href="#install-the-default-harness-delegate" id="install-the-default-harness-delegate"></a>

#### Create a new delegate token <a href="#create-a-new-delegate-token" id="create-a-new-delegate-token"></a>

You can install delegates from the Account, Project, or Org scope. In this example, we'll create a new token in the Account scope.

To create a new delegate token, do the following:

1. In Harness, select **Account Settings**, then select **Account Resources**. The Account Resources page opens.
2. Select **Delegates**. The Delegates list page opens.
3. Select the **Tokens** tab, then select **+New Token**. The **New Token** dialog opens.
4. Enter a token name, for example `firstdeltoken`.
5. Select **Apply**. Harness generates a new token for you.
6. Select **Copy** to copy and store the token in a temporary file.

   You will provide this token as an input parameter in the next installation step. The delegate will use this token to authenticate with the Harness Platform.

#### Get your Harness account ID <a href="#get-your-harness-account-id" id="get-your-harness-account-id"></a>

Along with the delegate token, you will also need to provide your Harness `accountId` as an input parameter during delegate installation. This `accountId` is present in every Harness URL. For example, in the following URL:

```
https://app.harness.io/ng/#/account/6_vVHzo9Qeu9fXvj-AcQCb/settings/overview
```

`6_vVHzo9Qeu9fXvj-AcQCb` is the `accountId`.

{% hint style="info" %}
**NOTE**

When you install a delegate via the Harness UI, several dependencies in this topic are prefilled for your convenience. This topic explains where to find the required information for CLI-based installation.
{% endhint %}

For more information, go to [View account info and subscribe to downtime alerts](/harness-platform/subscriptions-and-licenses/view-account-info-and-subscribe-to-alerts.md).

{% tabs %}
{% tab title="Kubernetes" %}

#### Prerequisite <a href="#prerequisite" id="prerequisite"></a>

Ensure that you have access to a Kubernetes cluster. For the purposes of this tutorial, we will use `minikube`.

**Install minikube**

* On Windows

  ```
  choco install minikube
  ```

  <div data-gb-custom-block data-tag="hint" data-style="info" class="hint hint-info"><p>For Chocolatey installation instructions, go to <a href="https://chocolatey.org/install">Installing Chocolatey</a> in the Chocolatey documentation.</p><p>For additional options to install minikube on Windows, go to <a href="https://minikube.sigs.k8s.io/docs/start/">minikube start</a> in the minikube documentation.</p></div>
* On macOS:

  ```
  brew install minikube
  ```

  <div data-gb-custom-block data-tag="hint" data-style="info" class="hint hint-info"><p>For Homebrew installation instructions, go to <a href="https://docs.brew.sh/Installation">Installation</a> in the Homebrew documentation.</p></div>

Now start minikube with the following config.

```
minikube start --memory 4g --cpus 4
```

Validate that you have kubectl access to your cluster.

```
kubectl get pods -A
```

Now that you have access to a Kubernetes cluster, you can install the delegate using any of the options below.

{% tabs %}
{% tab title="Helm Chart" %}

#### Install the Helm chart <a href="#install-the-helm-chart" id="install-the-helm-chart"></a>

As a prerequisite, you must have [Helm v3](https://helm.sh/docs/intro/install/) installed on the machine from which you connect to your Kubernetes cluster.

You can now install the delegate using the delegate Helm chart. First, add the `harness-delegate` Helm chart repo to your local Helm registry.

```
helm repo add harness-delegate https://app.harness.io/storage/harness-download/delegate-helm-chart/
helm repo update
helm search repo harness-delegate
```

We will use the `harness-delegate/harness-delegate-ng` chart in this tutorial.

```
NAME                                	CHART VERSION	APP VERSION	DESCRIPTION
harness-delegate/harness-delegate-ng	1.0.8        	1.16.0     	A Helm chart for deploying harness-delegate
```

Now we are ready to install the delegate. The following example installs/upgrades `firstk8sdel` delegate (which is a Kubernetes workload) in the `harness-delegate-ng` namespace using the `harness-delegate/harness-delegate-ng` Helm chart.

You can install delegates from the Account, Project, or Org scope. In this example, we'll install a delegate in the Account scope.

To install a delegate, do the following:

1. In Harness, select **Account Settings**, then select **Account Resources**. The Account Resources page opens.
2. Select **Delegates**. The Delegates list page opens.
3. Select **New Delegate**. The **New Delegate** dialog opens.

   ![](/files/U21zCDQtS6r5x92yUpg4)
4. Under **Select where you want to install your Delegate**, select **Kubernetes**.
5. Under **Install your Delegate**, select **Helm Chart**.
6. Copy the `helm upgrade` command.

   The command uses the default [values.yaml file](https://github.com/harness/delegate-helm-chart/blob/main/harness-delegate-ng/values.yaml) located in the [delegate Helm chart](https://github.com/harness/delegate-helm-chart) GitHub repo. To make persistent changes to one or more values, you can download and update the `values.yaml` file according to your requirements. Once you have updated the file, you can use it by running the upgrade command below.

   ```
      helm upgrade -i firstk8sdel --namespace harness-delegate-ng --create-namespace \
     harness-delegate/harness-delegate-ng \
     -f values.yaml \
     --set delegateName=firstk8sdel \
     --set accountId=PUT_YOUR_HARNESS_ACCOUNTID_HERE \
     --set delegateToken=PUT_YOUR_DELEGATE_TOKEN_HERE \
     --set managerEndpoint=PUT_YOUR_MANAGER_HOST_AND_PORT_HERE \
     --set delegateDockerImage=harness/delegate:yy.mm.verno \
     --set replicas=1 --set upgrader.enabled=true
   ```

{% hint style="info" %}
**NOTE**

To install a Helm delegate for Harness Self-Managed Enterprise Edition in an air-gapped environment, you must pass your certificate when you add the Helm repo.

```
helm repo add harness-delegate --ca-file <.PEM_FILE_PATH> <HELM_CHART_URL_FROM_UI>
```

For more information on requirements for air-gapped environments, go to [Install in an air-gapped environment](/self-managed-enterprise-edition/use-self-managed-enterprise-edition/smp-installationupgrade/helm-installation/install-in-an-air-gapped-environment.md).
{% endhint %}

7. Run the command.
   {% endtab %}

{% tab title="Terraform Helm Provider" %}

#### Create main.tf file <a href="#create-maintf-file" id="create-maintf-file"></a>

Harness uses a Terraform module for the Kubernetes delegate. This module uses the standard Terraform Helm provider to install the Helm chart onto a Kubernetes cluster whose config by default is stored in the same machine at the `~/.kube/config` path. Copy the following into a `main.tf` file stored on a machine from which you want to install your delegate.

```
module "delegate" {
  source = "harness/harness-delegate/kubernetes"
  version = "0.1.8"

  account_id = "PUT_YOUR_HARNESS_ACCOUNTID_HERE"
  delegate_token = "PUT_YOUR_DELEGATE_TOKEN_HERE"
  delegate_name = "firstk8sdel"
  namespace = "harness-delegate-ng"
  manager_endpoint = "PUT_YOUR_MANAGER_HOST_AND_PORT_HERE"
  delegate_image = "harness/delegate:yy.mm.verno"
  replicas = 1
  upgrader_enabled = false

  # Additional optional values to pass to the helm chart
  values = yamlencode({
    javaOpts: "-Xms64M"
  })
}

provider "helm" {
  kubernetes {
    config_path = "~/.kube/config"
  }
}
```

Now replace the variables in the file with your Harness account ID and delegate token values. Replace `PUT_YOUR_MANAGER_HOST_AND_PORT_HERE` with the Harness Manager Endpoint noted below. For Harness SaaS accounts, you can find your Harness Cluster Location on the **Account Overview** page under the **Account Settings** section of the left navigation.

| Harness Cluster Location | Harness Manager Endpoint on Harness Cluster |
| ------------------------ | ------------------------------------------- |
| SaaS prod-1              | `https://app.harness.io`                    |
| SaaS prod-2              | `https://app.harness.io/gratis`             |
| SaaS prod-3              | `https://app3.harness.io`                   |

#### Run Terraform init, plan, and apply <a href="#run-terraform-init-plan-and-apply" id="run-terraform-init-plan-and-apply"></a>

Initialize Terraform. This downloads the Terraform Helm provider to your machine.

```
terraform init
```

Run the following step to view the changes Terraform is going to make on your behalf.

```
terraform plan
```

Finally, run this step to make Terraform install the Kubernetes delegate using the Helm provider.

```
terraform apply
```

When prompted by Terraform if you want to continue with the apply step, type `yes`, and then you will see output similar to the following.

```
helm_release.delegate: Creating...
helm_release.delegate: Still creating... [10s elapsed]
helm_release.delegate: Still creating... [20s elapsed]
helm_release.delegate: Still creating... [30s elapsed]
helm_release.delegate: Still creating... [40s elapsed]
helm_release.delegate: Still creating... [50s elapsed]
helm_release.delegate: Still creating... [1m0s elapsed]
helm_release.delegate: Creation complete after 1m0s [id=firstk8sdel]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
```

{% endtab %}

{% tab title="Kubernetes Manifest" %}

#### Download a Kubernetes manifest template <a href="#download-a-kubernetes-manifest-template" id="download-a-kubernetes-manifest-template"></a>

```
curl -LO https://raw.githubusercontent.com/harness/delegate-kubernetes-manifest/main/harness-delegate.yaml
```

#### Replace variables in the template <a href="#replace-variables-in-the-template" id="replace-variables-in-the-template"></a>

Open the `harness-delegate.yaml` file in a text editor and replace `PUT_YOUR_DELEGATE_NAME_HERE`, `PUT_YOUR_HARNESS_ACCOUNTID_HERE`, and `PUT_YOUR_DELEGATE_TOKEN_HERE` with your delegate name (for example, `firstk8sdel`), Harness `accountId`, and delegate token values, respectively.

Replace the `PUT_YOUR_MANAGER_HOST_AND_PORT_HERE` variable with the Harness Manager Endpoint noted below. For Harness SaaS accounts, you can find your Harness Cluster Location on the **Account Overview** page under the **Account Settings** section of the left navigation.

| Harness Cluster Location | Harness Manager Endpoint on Harness Cluster |
| ------------------------ | ------------------------------------------- |
| SaaS prod-1              | `https://app.harness.io`                    |
| SaaS prod-2              | `https://app.harness.io/gratis`             |
| SaaS prod-3              | `https://app3.harness.io`                   |

#### Apply the Kubernetes manifest <a href="#apply-the-kubernetes-manifest" id="apply-the-kubernetes-manifest"></a>

```
kubectl apply -f harness-delegate.yaml
```

{% endtab %}
{% endtabs %}
{% endtab %}

{% tab title="Docker" %}

#### Prerequisites <a href="#prerequisites" id="prerequisites"></a>

Ensure that you have the Docker runtime installed on your host. If not, use one of the following options to install Docker:

* [Docker for Mac](https://docs.docker.com/desktop/install/mac-install/)
* [Docker for CentOS](https://docs.docker.com/engine/install/centos/)
* [Docker for Ubuntu](https://docs.docker.com/engine/install/ubuntu/)
* [Docker for Debian](https://docs.docker.com/engine/install/debian/)
* [Docker for Windows](https://docs.docker.com/desktop/install/windows-install/)

#### Install on Docker

You can install delegates from the Account, Project, or Org scope. In this example, we'll install a delegate in the Project scope.

To install a delegate, do the following:

1. In Harness, select your project, then select **Project Settings**.
2. Under **Project-level resources**, select **Delegates**.
3. Select **Install a Delegate** to open the **New Delegate** dialog.
4. Under **Select where you want to install your Delegate**, select **Docker**.
5. Under **Install your Delegate**, enter a **Delegate Name**.
6. Copy the `docker run` command.

   ```bash
   docker run --cpus=1 --memory=2g \
     -e DELEGATE_NAME=docker-delegate \
     -e NEXT_GEN="true" \
     -e DELEGATE_TYPE="DOCKER" \
     -e ACCOUNT_ID=YOUR_HARNESS_ACCOUNTID_ \
     -e DELEGATE_TOKEN=YOUR_DELEGATE_TOKEN \
     -e DELEGATE_TAGS="" \
     -e MANAGER_HOST_AND_PORT=YOUR_MANAGER_HOST_AND_PORT \
     harness/delegate:yy.mm.verno
   ```

   <div data-gb-custom-block data-tag="hint" data-style="info" class="hint hint-info"><p>The <code>docker run</code> command doesn't allow you to select the delegate token. You can replace the token in the command with another token if required.</p></div>

   <div data-gb-custom-block data-tag="hint" data-style="info" class="hint hint-info"><p>Steps 6 and 7 are optional when installing a delegate using the CLI flow.</p></div>
7. (Optional) Replace the `YOUR_MANAGER_HOST_AND_PORT_HERE` variable with the Harness Manager Endpoint noted below. For Harness SaaS accounts, to find your Harness cluster location, select **Account Settings**, and then select **Overview**. In **Account Overview**, look in **Account Settings**. It is listed next to **Harness Cluster Hosting Account**.

   For more information, go to [View account info and subscribe to downtime alerts](/harness-platform/subscriptions-and-licenses/view-account-info-and-subscribe-to-alerts.md).

   ![](/files/jZKQ1lcUbDrR4ADEc2s3)

   For Harness CDCE, the endpoint varies based on the Docker vs. Helm installation options.

   | Harness Cluster Location | Harness Manager Endpoint on Harness Cluster |
   | ------------------------ | ------------------------------------------- |
   | SaaS prod-1              | `https://app.harness.io`                    |
   | SaaS prod-2              | `https://app.harness.io/gratis`             |
   | SaaS prod-3              | `https://app3.harness.io`                   |
8. Run the command.
   {% endtab %}
   {% endtabs %}

### Ephemeral Storage in Delegate Helm Charts <a href="#ephemeral-storage-in-delegate-helm-charts" id="ephemeral-storage-in-delegate-helm-charts"></a>

To manage temporary disk space efficiently, you can configure ephemeral storage for the Harness Delegate using Helm charts. This guide walks you through defining custom volumes and applying the configuration during Helm installation.

The setup is cloud-agnostic and works across providers by adjusting the storage class as needed.

1. Create a `values.yaml` file and add the following configuration to it.

   ```yaml
      custom_mounts:
      - mountPath: "/scratch"
         name: scratch-volume

      custom_volumes:
      - name: scratch-volume
         ephemeral:
            volumeClaimTemplate:
            metadata:
               labels:
                  type: <YOUR-TYPE-REFERENCE>
            spec:
               accessModes: [ "ReadWriteOnce" ]
               storageClassName: "<YOUR-STORAGE-CLASS>"
               resources:
                  requests:
                  storage: <STORAGE-SIZE>
   ```

   <div data-gb-custom-block data-tag="hint" data-style="info" class="hint hint-info"><p>Before proceeding with installation, ensure a suitable StorageClass exists in your cluster. This is required for provisioning ephemeral volumes as defined in your values.yaml.</p><p>You can check the available storage classes using:</p><pre class="language-bash"><code class="lang-bash">kubectl get storageclass
   </code></pre><p>If your cluster doesn’t have a suitable <code>StorageClass</code>, you can create one using:</p><pre class="language-bash"><code class="lang-bash">kubectl apply -f storage-class.yaml
   </code></pre><p>Example <code>storage-class.yaml</code>:</p><pre class="language-yaml"><code class="lang-yaml">apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
   name: &#x3C;YOUR-STORAGE-CLASS-NAME>
   provisioner: &#x3C;YOUR-STORAGE-PROVISIONER>  # e.g., kubernetes.io/aws-ebs, pd.csi.storage.gke.io
   parameters:
   type: &#x3C;YOUR-VOLUME-TYPE>               # e.g., gp2 for AWS
   reclaimPolicy: &#x3C;YOUR-RECLAIM-POLICY>     # e.g., Retain or Delete
   volumeBindingMode: WaitForFirstConsumer
   </code></pre><p>After creating the <code>StorageClass</code>, configure it in the Helm chart by setting: <code>--set persistence.storageClass=&#x3C;YOUR-STORAGE-CLASS-NAME></code></p></div>
2. Install the Helm chart using the example below, which applies the configuration from `values.yaml` file we created earlier:

   ```yaml
      helm upgrade -i <YOUR-DELEGATE-NAME> --namespace harness-delegate-ng --create-namespace \
      harness-delegate/harness-delegate-ng \
      --set delegateName=<YOUR-DELEGATE-NAME> \
      --set accountId=XXXXXXXXXXXXXXXX \
      --set delegateToken=XXXXXXXXXXXXXXXXXXXXXX \
      --set managerEndpoint=https://<YOUR-URL>.harness.io \
      --set delegateDockerImage=us-west1-docker.pkg.dev/gar-setup/docker/delegate:<DELEGATE-TAG-VERSION> \
      --set replicas=1 --set upgrader.enabled=true \
      -f values.yaml
   ```
3. Verify that the ephemeral storage has been mounted correctly by inspecting the pod’s volume mounts.

   * Get the Pod Name

     ```bash
     kubectl get pods -n harness-delegate-ng
     ```

     Output:

     ```bash
     NAME                                  READY   STATUS    RESTARTS   AGE
     delegate-ephemeral-storage            1/1     Running   0          2m
     ```
   * Describe the Pod

     ```bash
     kubectl describe pod delegate-ephemeral-storage -n harness-delegate-ng
     ```

     Look for the similar section below in your output

     ```bash
     Volumes:
     scratch-volume:
        Type:       PersistentVolumeClaim (a reference to a PVC)
        ClaimName:  scratch-volume-delegate-ephemeral-storage
        ReadOnly:   false

     Mounts:
     /scratch from scratch-volume (rw)
     ```

     This confirms that your ephemeral volume (scratch-volume) is mounted to /scratch in the pod.

   <div data-gb-custom-block data-tag="hint" data-style="warning" class="hint hint-warning"><p><strong>IMPORTANT NOTE:</strong></p><p>Ephemeral storage is automatically deleted when the pod is terminated, and a new volume is created when a new pod starts. This ensures the storage is tied to the pod’s lifecycle and is not persistent.</p></div>

### Deploy using a custom role <a href="#deploy-using-a-custom-role" id="deploy-using-a-custom-role"></a>

During delegate installation, you have the option to deploy using a custom role. To use a custom role, you must edit the delegate YAML file.

Harness supports the following custom roles:

* `cluster-admin`
* `cluster-viewer`
* `namespace-admin`
* custom cluster roles

To deploy using a custom cluster role, do the following:

1. Open the delegate YAML file in your text editor.
2. Add the custom cluster role to the `roleRef` field in the delegate YAML.

   ```yaml
   ---
   apiVersion: rbac.authorization.k8s.io/v1beta1
   kind: ClusterRoleBinding
   metadata:
     name: harness-delegate-cluster-admin
   subjects:
     - kind: ServiceAccount
       name: default
       namespace: harness-delegate-ng
   roleRef:
     kind: ClusterRole
     name: cluster-admin
     apiGroup: rbac.authorization.k8s.io
   ---
   ```

   In this example, the `cluster-admin` role is defined.
3. Save the delegate YAML file.

### Verify delegate connectivity <a href="#verify-delegate-connectivity" id="verify-delegate-connectivity"></a>

Select **Continue**. After the health checks pass, your delegate is available for you to use. Select **Done** and verify your new delegate is listed.

#### Helm chart & Terraform Helm provider <a href="#helm-chart-and-terraform-helm-provider" id="helm-chart-and-terraform-helm-provider"></a>

![Delegate Available](/files/S9Anurfa6PM2cT6sXfwz)

#### Kubernetes manifest <a href="#kubernetes-manifest" id="kubernetes-manifest"></a>

![Delegate Available](/files/WZOTfEAGBakz9AvlKCDU)

#### Docker <a href="#docker" id="docker"></a>

![Delegate Available](/files/Fr8hdt0FUUwrWUER9ZGF)

You can now route communication to external systems in Harness connectors and pipelines by selecting this delegate via a delegate selector.

Delegate selectors do not override service infrastructure connectors. Delegate selectors only determine the delegate that executes the operations of your pipeline.

### Troubleshooting <a href="#troubleshooting" id="troubleshooting"></a>

The delegate installer provides troubleshooting information for each installation process. If the delegate cannot be verified, select **Troubleshoot** for steps you can use to resolve the problem. This section includes the same information.

Harness asks for feedback after the troubleshooting steps. You are asked, **Did the delegate come up?**

If the steps did not resolve the problem, select **No**, and use the form to describe the issue. You'll also find links to Harness Support and to [Delegate docs](/harness-platform/use-harness-platform/delegates/delegate/delegate-concepts/delegate-overview.md).

{% tabs %}
{% tab title="Helm Chart" %}
Use the following steps to troubleshoot your installation of the delegate using Helm.

1. Verify that Helm is correctly installed:

   Check for Helm:

   ```
   helm
   ```

   And then check for the installed version of Helm:

   ```
   helm version
   ```

   If you receive the message `Error: rendered manifests contain a resource that already exists...`, delete the existing namespace, and retry the Helm upgrade command to deploy the delegate.

   For further instructions on troubleshooting your Helm installation, go to [Helm troubleshooting guide](https://helm.sh/docs/faq/troubleshooting/).
2. Check the status of the delegate on your cluster:

   ```
   kubectl describe pods -n <NAMESPACE>
   ```
3. If the pod did not start, check the delegate logs:

   ```
   kubectl logs -f <DELEGATE_NAME> -n <NAMESPACE>
   ```

   If the state of the delegate pod is `CrashLoopBackOff`, check your allocation of compute resources (CPU and memory) to the cluster. A state of `CrashLoopBackOff` indicates insufficient Kubernetes cluster resources.
4. If the delegate pod is not healthy, use the `kubectl describe` command to get more information:

   ```
   kubectl describe <POD_NAME> -n <NAMESPACE>
   ```

{% endtab %}

{% tab title="Terraform Helm Provider" %}
Use the following steps to troubleshoot your installation of the delegate using Terraform.

1. Verify that Terraform is correctly installed:

   ```
   terraform -version
   ```

   For further instructions on troubleshooting your installation of Terraform, go to the [Terraform troubleshooting guide](https://developer.hashicorp.com/terraform/enterprise/vcs/troubleshooting).
2. Check the status of the delegate on your cluster:

   ```
   kubectl describe pods -n <namespace>
   ```
3. If the pod did not start, check the delegate logs:

   ```
   kubectl logs -f <DELEGATE_NAME> -n <NAMESPACE>
   ```

   If the state of the delegate pod is `CrashLoopBackOff`, check your allocation of compute resources (CPU and memory) to the cluster. A state of `CrashLoopBackOff` indicates insufficient Kubernetes cluster resources.
4. If the delegate pod is not healthy, use the `kubectl describe` command to get more information:

   ```
   kubectl describe <POD_NAME> -n <NAMESPACE>
   ```

{% endtab %}

{% tab title="Kubernetes Manifest" %}
Use the following steps to troubleshoot your installation of the delegate using Kubernetes.

1. Check the status of the delegate on your cluster:

   ```
   kubectl describe pods -n <NAMESPACE>
   ```
2. If the pod did not start, check the delegate logs:

   ```
   kubectl logs -f <DELEGATE_NAME> -n <NAMESPACE>
   ```

   If the state of the delegate pod is `CrashLoopBackOff`, check your allocation of compute resources (CPU and memory) to the cluster. A state of `CrashLoopBackOff` indicates insufficient Kubernetes cluster resources.
3. If the delegate pod is not healthy, use the `kubectl describe` command to get more information:

   ```
   kubectl describe <POD_NAME> -n <NAMESPACE>
   ```

{% endtab %}

{% tab title="Docker" %}
Use the following steps to troubleshoot your installation of the delegate using Docker:

1. Check the status of the delegate on your cluster:

   ```
   docker container ls -a
   ```
2. If the pod is not running, check the delegate logs:

   ```
   docker container logs <DELEGATE_NAME> -f
   ```
3. Restart the delegate container. To stop the container:

   ```
   docker container stop <DELEGATE_NAME>
   ```

   To start the container:

   ```
   docker container start <DELEGATE_NAME>
   ```
4. Make sure the container has sufficient CPU and memory resources. If not, remove the older containers:

   ```
   docker container rm [container id]
   ```

{% endtab %}
{% endtabs %}