> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/argoproj/argo-cd/llms.txt
> Use this file to discover all available pages before exploring further.

# Kubernetes Installation

> Install Argo CD on Kubernetes using standard manifests

This guide covers the standard (non-HA) installation of Argo CD on Kubernetes. This installation is suitable for testing, demonstrations, and non-production environments.

<Warning>
  The standard installation is **not recommended for production use**. For production deployments, use the [High Availability installation](/installation/high-availability).
</Warning>

## Prerequisites

* Kubernetes cluster (version 1.27+)
* kubectl CLI configured to access your cluster
* Cluster-admin access (for standard installation)

## Installation

<Steps>
  <Step title="Create the namespace">
    Create a dedicated namespace for Argo CD:

    ```bash theme={null}
    kubectl create namespace argocd
    ```
  </Step>

  <Step title="Apply the installation manifest">
    Install Argo CD using the stable release:

    ```bash theme={null}
    kubectl apply -n argocd --server-side --force-conflicts \
      -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
    ```

    <Note>
      The `--server-side --force-conflicts` flags are required because some Argo CD CRDs exceed the size limit for client-side apply.
    </Note>

    For a specific version, replace `stable` with the version tag:

    ```bash theme={null}
    kubectl apply -n argocd --server-side --force-conflicts \
      -f https://raw.githubusercontent.com/argoproj/argo-cd/v2.14.0/manifests/install.yaml
    ```
  </Step>

  <Step title="Verify installation">
    Wait for all pods to be ready:

    ```bash theme={null}
    kubectl get pods -n argocd
    ```

    You should see the following components:

    ```
    NAME                                               READY   STATUS
    argocd-application-controller-0                    1/1     Running
    argocd-applicationset-controller-xxx               1/1     Running
    argocd-dex-server-xxx                              1/1     Running
    argocd-notifications-controller-xxx                1/1     Running
    argocd-redis-xxx                                   1/1     Running
    argocd-repo-server-xxx                             1/1     Running
    argocd-server-xxx                                  1/1     Running
    ```
  </Step>
</Steps>

## Installed Components

The standard installation includes the following components:

<Tabs>
  <Tab title="Core Components">
    ### API Server (argocd-server)

    * **Type:** Deployment (1 replica)
    * **Purpose:** Provides the Web UI and gRPC/REST API
    * **Exposes:** Port 8080 (HTTP), 8083 (HTTPS)

    ### Application Controller (argocd-application-controller)

    * **Type:** StatefulSet (1 replica)
    * **Purpose:** Monitors applications and reconciles desired state
    * **Watches:** Git repositories and Kubernetes clusters

    ### Repository Server (argocd-repo-server)

    * **Type:** Deployment (1 replica)
    * **Purpose:** Clones Git repos and generates manifests
    * **Supports:** Helm, Kustomize, Jsonnet, and custom plugins
  </Tab>

  <Tab title="Supporting Services">
    ### Redis (argocd-redis)

    * **Type:** Deployment (1 replica)
    * **Purpose:** Caching and state management
    * **Note:** Single instance (not HA)

    ### Dex (argocd-dex-server)

    * **Type:** Deployment (1 replica)
    * **Purpose:** OIDC identity provider
    * **Supports:** SSO integrations

    ### ApplicationSet Controller

    * **Type:** Deployment (1 replica)
    * **Purpose:** Manages ApplicationSet resources
    * **Enables:** Multi-cluster application templating

    ### Notifications Controller

    * **Type:** Deployment (1 replica)
    * **Purpose:** Sends notifications for application events
    * **Integrates:** Slack, email, webhooks, etc.
  </Tab>
</Tabs>

## Manifest Structure

The `install.yaml` manifest contains:

```yaml theme={null}
# CustomResourceDefinitions
- Application CRD
- ApplicationSet CRD
- AppProject CRD

# Namespace Resources
- ServiceAccounts
- Roles and RoleBindings
- Deployments and StatefulSets
- Services
- ConfigMaps
- Secrets

# Cluster Resources
- ClusterRole (argocd-application-controller)
- ClusterRoleBinding
```

<Warning>
  The ClusterRoleBinding is bound to the ServiceAccount in the `argocd` namespace. If you change the namespace, update the ClusterRoleBinding accordingly.
</Warning>

## Accessing Argo CD

<Tabs>
  <Tab title="Port Forwarding">
    Access the API server using kubectl port-forward:

    ```bash theme={null}
    kubectl port-forward svc/argocd-server -n argocd 8080:443
    ```

    Then access the UI at [https://localhost:8080](https://localhost:8080)
  </Tab>

  <Tab title="Load Balancer">
    Expose the API server using a LoadBalancer service:

    ```bash theme={null}
    kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'
    ```

    Get the external IP:

    ```bash theme={null}
    kubectl get svc argocd-server -n argocd
    ```
  </Tab>

  <Tab title="Ingress">
    Create an Ingress resource for the API server:

    ```yaml theme={null}
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
      name: argocd-server-ingress
      namespace: argocd
      annotations:
        nginx.ingress.kubernetes.io/ssl-passthrough: "true"
        nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
    spec:
      ingressClassName: nginx
      rules:
      - host: argocd.example.com
        http:
          paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: argocd-server
                port:
                  name: https
      tls:
      - hosts:
        - argocd.example.com
        secretName: argocd-server-tls
    ```
  </Tab>
</Tabs>

## Initial Admin Password

Retrieve the initial admin password:

```bash theme={null}
kubectl get secret argocd-initial-admin-secret -n argocd -o jsonpath="{.data.password}" | base64 -d
```

Login with:

* **Username:** `admin`
* **Password:** (retrieved from command above)

<Note>
  Change the admin password after first login and delete the `argocd-initial-admin-secret` secret.
</Note>

## Namespace-Level Installation

For installations that only deploy to external clusters, use the namespace-install variant:

```bash theme={null}
# Install CRDs first
kubectl apply --server-side --force-conflicts \
  -k https://github.com/argoproj/argo-cd/manifests/crds\?ref\=stable

# Install namespace-scoped resources
kubectl create namespace argocd
kubectl apply -n argocd --server-side --force-conflicts \
  -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/namespace-install.yaml
```

<Info>
  The namespace-install.yaml does **not** include:

  * ClusterRole or ClusterRoleBinding
  * CRDs (must be installed separately)
  * Ability to deploy to the local cluster without explicit credentials
</Info>

## Installing with Kustomize

Create a `kustomization.yaml` file:

```yaml theme={null}
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

namespace: argocd

resources:
  - https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

# Optional: Add customizations
patches:
  - patch: |-
      - op: replace
        path: /spec/replicas
        value: 2
    target:
      kind: Deployment
      name: argocd-repo-server
```

Apply with:

```bash theme={null}
kustomize build . | kubectl apply --server-side --force-conflicts -f -
```

## Custom Namespace

To install in a custom namespace:

```yaml theme={null}
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

namespace: my-argocd

resources:
  - https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

patches:
  - patch: |-
      - op: replace
        path: /subjects/0/namespace
        value: my-argocd
    target:
      kind: ClusterRoleBinding
```

## Upgrading

To upgrade to a new version:

```bash theme={null}
kubectl apply -n argocd --server-side --force-conflicts \
  -f https://raw.githubusercontent.com/argoproj/argo-cd/<version>/manifests/install.yaml
```

Replace `<version>` with the desired version tag (e.g., `v2.14.0`).

<Warning>
  Always review the [upgrade notes](https://argo-cd.readthedocs.io/en/stable/operator-manual/upgrading/overview/) before upgrading to a new version.
</Warning>

## Uninstalling

To remove Argo CD:

```bash theme={null}
kubectl delete -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
kubectl delete namespace argocd
```

## Next Steps

<CardGroup cols={2}>
  <Card title="Configure SSO" icon="key" href="/configuration/sso">
    Set up Single Sign-On authentication
  </Card>

  <Card title="Add Repositories" icon="git-alt" href="/configuration/repositories">
    Connect Git repositories to Argo CD
  </Card>

  <Card title="Create Applications" icon="rocket" href="/applications/creating-apps">
    Deploy your first application
  </Card>

  <Card title="High Availability" icon="layer-group" href="/installation/high-availability">
    Upgrade to HA for production
  </Card>
</CardGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Pods stuck in Pending state">
    Check resource requests and node capacity:

    ```bash theme={null}
    kubectl describe pod -n argocd <pod-name>
    kubectl describe nodes
    ```

    The standard installation requires moderate resources. Consider adjusting resource requests if needed.
  </Accordion>

  <Accordion title="Cannot access the UI">
    Verify the argocd-server service is running:

    ```bash theme={null}
    kubectl get svc argocd-server -n argocd
    kubectl logs -n argocd deploy/argocd-server
    ```

    Check if port-forwarding is active and not blocked by firewalls.
  </Accordion>

  <Accordion title="CRD size limit errors">
    If you see errors about CRD size limits, ensure you're using the `--server-side --force-conflicts` flags:

    ```bash theme={null}
    kubectl apply -n argocd --server-side --force-conflicts -f <manifest>
    ```
  </Accordion>
</AccordionGroup>