Devtron is a tool integration platform for Kubernetes.

Devtron deeply integrates with products across the lifecycle of microservices i.e., CI/CD, security, cost, debugging, and observability via an intuitive web interface. Devtron helps you to deploy, observe, manage & debug the existing Helm apps in all your clusters.

Devtron's Key Features:

No Code Software Delivery Workflow for Kubernetes

• Workflow which understands the domain of Kubernetes, testing, CD, SecOps so that you don't have to write scripts

• Reusable and composable components so that workflows are easy to construct and reason through

Multi-cloud Deployment

• Deploy to multiple Kubernetes clusters on multiple cloud/on-prem from one Devtron setup

• Works for all cloud providers and on-premise Kubernetes clusters

Easy DevSecOps Integration

• Multi-level security policy at global, cluster, environment, and application-level for efficient hierarchical policy management

• Behavior-driven security policy

• Define policies and exceptions for Kubernetes resources

• Define policies for events for faster resolution

Application Debugging Dashboard

• One place for all historical Kubernetes events

• Access all manifests securely, such as secret obfuscation

• Application metrics for CPU, RAM, HTTP status code, and latency with a comparison between new and old

• Advanced logging with grep and JSON search

• Intelligent correlation between events, logs for faster triangulation of issue

• Auto issue identification

Enterprise-Grade Security and Compliances

• Fine-grained access control; control who can edit the configuration and who can deploy.

• Audit log to know who did what and when

• History of all CI and CD events

• Kubernetes events impacting application

• Relevant cloud events and their impact on applications

• Advanced workflow policies like blackout window, branch environment relationship to secure build and deployment pipelines

Implements GitOps

• GitOps exposed through API and UI so that you don't have to interact with git CLI

• GitOps backed by Postgres for easy analysis

• Enforce finer access control than Git

Operational Insights

• Deployment metrics to measure the success of the agile process. It captures MTTR, change failure rate, deployment frequency, and deployment size out of the box.

• Audit log to understand the failure causes

• Monitor changes across deployments and reverts easily

Compatibility Notes

• Devtron uses a modified version of Argo Rollout.

• Application metrics only work for K8s version 1.16+

Contributing Guidelines

Check out our contributing guidelines. Directions for opening issues, coding standards, and notes on our development processes are all included.

Community

Get updates on Devtron's development and chat with the project maintainers, contributors, and community members.

• Join the Discord Community

• Follow @DevtronL on Twitter

• Raise feature requests, suggest enhancements, report bugs at GitHub issues

• Read the Devtron blog

Vulnerability Reporting

We, at Devtron, take security and our users' trust very seriously. If you believe you have found a security issue in Devtron, please responsibly disclose it by contacting us at security@devtron.ai.

This section includes information about the minimum requirements you need to install and use Devtron.

Devtron is installed over a Kubernetes cluster. Once you create a Kubernetes cluster, Devtron can be installed standalone or along with CI/CD integration:

• Devtron with CI/CD: Devtron installation with the CI/CD integration is used to perform CI/CD, security scanning, GitOps, debugging, and observability.

• Helm Dashboard by Devtron: The Helm Dashboard by Devtron, which is a standalone installation, includes functionalities to deploy, observe, manage, and debug existing Helm applications in multiple clusters. You can also install integrations from Devtron Stack Manager.

In this section, we will cover the basic details on how you can quickly get started with Devtron. First, lets see what are the prerequisite requirements before you install Devtron.

Prerequisites

• Create a Kubernetes cluster, preferably K8s version 1.16 or higher

• Helm Installation

• Recommended Resources

Create a Kubernetes Cluster

You can create any Kubernetes cluster (preferably K8s version 1.16 or higher) for installing Devtron.

You can create a cluster using one of the following cloud providers as per your requirements:

Install Helm

Make sure to install helm.

Recommended Resources

The minimum requirements for installing Helm Dashboard by Devtron and Devtron with CI/CD as per the number of applications you want to manage on Devtron are provided below:

• For configuring small resources (to manage not more than 5 apps on Devtron):

• For configuring medium/larger resources (to manage more than 5 apps on Devtron):

Refer to the Override Configurations section for more information.

Note:

• Please make sure that the recommended resources are available on your Kubernetes cluster before you proceed with Devtron installation.

• It is NOT recommended to use brustable CPU VMs (T series in AWS, B Series in Azure and E2/N1 in GCP) for Devtron installation to experience consistency in performance.

Installation of Devtron

You can install Devtron standalone (Helm Dashboard by Devtron) or along with CI/CD integration. Or, you can upgrade Devtron to the latest version.

Choose one of the options as per your requirements:

Devtron is installed over a Kubernetes cluster. Once you create a Kubernetes cluster, Devtron can be installed standalone or along with CI/CD integration.

Choose one of the options as per your requirements:

Note: If you have questions, please let us know on our discord channel.

In this section, we describe the steps in detail on how you can install Devtron with CI/CD by enabling GitOps during the installation.

Before you begin

Install if you have not installed it.

Install Devtron with CI/CD along with GitOps (Argo CD)

Run the following command to install the latest version of Devtron with CI/CD along with GitOps (Argo CD) module:

Note: If you want to configure Blob Storage during the installation, refer .

Install Multi-Architecture Nodes (ARM and AMD)

To install Devtron on clusters with the multi-architecture nodes (ARM and AMD), append the Devtron installation command with --set installer.arch=multi-arch.

Note:

Configure Blob Storage during Installation

Configuring Blob Storage in your Devtron environment allows you to store build logs and cache. In case, if you do not configure the Blob Storage, then:

• You will not be able to access the build and deployment logs after an hour.

• Build time for commit hash takes longer as cache is not available.

• Artifact reports cannot be generated in pre/post build and deployment stages.

Choose one of the options to configure blob storage:

Check Status of Devtron Installation

Note: The installation takes about 15 to 20 minutes to spin up all of the Devtron microservices one by one.

Run the following command to check the status of the installation:

The command executes with one of the following output messages, indicating the status of the installation:

Check the installer logs

Run the following command to check the installer logs:

Devtron dashboard

Run the following command to get the Devtron dashboard URL:

You will get an output similar to the example shown below:

Use the hostname aaff16e9760594a92afa0140dbfd99f7-305259315.us-east-1.elb.amazonaws.com (Loadbalancer URL) to access the Devtron dashboard.

Note: If you do not get a hostname or receive a message that says "service doesn't exist," it means Devtron is still installing. Please wait until the installation is completed.

Note: You can also use a CNAME entry corresponding to your domain/subdomain to point to the Loadbalancer URL to access at a customized domain.

Devtron Admin credentials

When you install Devtron for the first time, it creates a default admin user and password (with unrestricted access to Devtron). You can use that credentials to log in as an administrator.

After the initial login, we recommend you set up any SSO service like Google, GitHub, etc., and then add other users (including yourself). Subsequently, all the users can use the same SSO (let's say, GitHub) to log in to Devtron's dashboard.

The section below will help you understand the process of getting the administrator credentials.

For Devtron version v0.6.0 and higher

Username: admin Password: Run the following command to get the admin password:

Regular backups for Devtron PostgreSQL and ArgoCD are crucial components of a disaster recovery plan, as they protect against potential data loss due to unforeseen circumstances. This documentation provides instructions on how to take backups of Devtron and store them either on AWS S3 or Azure containers.

1. Go to the devtron chart store and search for devtron-backups chart.

1. Select the devtron-backups and click Configure & Deploy.

2. Now follow either of the options described below according to your Cloud provider.

AWS S3 Backup

To store Devtron backups on AWS S3, please follow these steps:

1. Create an S3 bucket to store the Devtron backup, you can configure the bucket to delete all the objects older than 15/30 days.

2. Create a user with sufficient permissions to push to the S3 bucket created in step 1.

3. Obtain the access key and secret access key for the created user.

4. Configure the devtron-backups chart for AWS S3 by selecting the appropriate options:

1. Deploy the chart, and the Devtron backup will be automatically uploaded to the AWS S3 bucket at the scheduled intervals.

Azure Containers Backup

To store Devtron backups on Azure Containers, please follow these steps:

1. Create a storage account in Azure.

2. Within the storage account, create two containers for the Devtron backup.

3. Navigate to Security + Networking > Access Key section in Azure and copy the Access Key:

1. Configure the devtron-backups chart for Azure Containers by providing the Access Key:

1. Before deploying the backup chart, ensure that AWS.enabled is set to false. This will ensure that Devtron backup will be automatically uploaded to the configured Azure containers on the scheduled intervals.

By following these steps, you can ensure that your Devtron data is securely backed up and protected against any potential data loss, enabling you to recover quickly in case of emergencies.

Introduction

In certain scenarios, you may need to deploy Devtron to a Kubernetes cluster that isn’t connected to the internet. Such air-gapped environments are used for various reasons, particularly in industries with strict regulatory requirements like healthcare, banking, and finance. This is because air-gapped environments aren't exposed to the public internet; therefore, they create a controlled and secure space for handling sensitive data and operations.

Prerequisites

1. Install podman or docker on the VM from where you're executing the installation commands.

2. Clone the Devtron Helm chart:

   Copy

   git clone https://github.com/devtron-labs/devtron.git
   cd devtron

3. Set the values of TARGET_REGISTRY, TARGET_REGISTRY_USERNAME, and TARGET_REGISTRY_TOKEN. This registry should be accessible from the VM where you are running the cloning script and the K8s cluster where you’re installing Devtron.

Docker Instructions

Platform Selection

For Linux/amd64

```bash
export PLATFORM="linux/amd64"
```

For Linux/arm64

```bash
export PLATFORM="linux/arm64"
```

1. Set the environment variables

   Copy

   # Set the source registry URL
   export SOURCE_REGISTRY="quay.io/devtron"
   
   # Set the target registry URL, username, and token/password
   export TARGET_REGISTRY=""
   export TARGET_REGISTRY_USERNAME=""
   export TARGET_REGISTRY_TOKEN=""
   
   # Set the source and target image file names with default values if not already set
   SOURCE_IMAGES_LIST="${SOURCE_IMAGES_LIST:=devtron-images.txt.source}"
   TARGET_IMAGES_LIST="${TARGET_IMAGES_LIST:=devtron-images.txt.target}"

2. Log in to the target Docker registry

   Copy

   docker login -u $TARGET_REGISTRY_USERNAME -p $TARGET_REGISTRY_TOKEN $TARGET_REGISTRY

3. Clone the images

   Copy

   while IFS= read -r source_image; do
     # Check if the source image belongs to the quay.io/devtron registry
     if [[ "$source_image" == quay.io/devtron/* ]]; then
       # Replace the source registry with the target registry in the image name
       target_image="${source_image/quay.io\/devtron/$TARGET_REGISTRY}"
   
     # Check if the source image belongs to the quay.io/argoproj registry
     elif [[ "$source_image" == quay.io/argoproj/* ]]; then
       # Replace the source registry with the target registry in the image name
       target_image="${source_image/quay.io\/argoproj/$TARGET_REGISTRY}"
   
     # Check if the source image belongs to the public.ecr.aws/docker/library registry
     elif [[ "$source_image" == public.ecr.aws/docker/library/* ]]; then
       # Replace the source registry with the target registry in the image name
       target_image="${source_image/public.ecr.aws\/docker\/library/$TARGET_REGISTRY}"
     fi
   
     # Pull the image from the source registry
     docker pull --platform $PLATFORM $source_image
   
     # Tag the image with the new target registry name
     docker tag $source_image $target_image
   
     # Push the image to the target registry
     docker push $target_image
   
     # Output the updated image name
     echo "Updated image: $target_image"
   
     # Append the new image name to the target image file
     echo "$target_image" >> "$TARGET_IMAGES_LIST"
   
   done < "$SOURCE_IMAGES_LIST"

Podman Instructions

For Multi-arch

1. Set the environment variables

   Copy

   export SOURCE_REGISTRY="quay.io/devtron"
   export SOURCE_REGISTRY_TOKEN=#Enter token provided by Devtron team
   export TARGET_REGISTRY=#Enter target registry url 
   export TARGET_REGISTRY_USERNAME=#Enter target registry username 
   export TARGET_REGISTRY_TOKEN=#Enter target registry token/password

2. Log in to the target Podman registry

   Copy

   podman login -u $TARGET_REGISTRY_USERNAME -p $TARGET_REGISTRY_TOKEN $TARGET_REGISTRY

3. Clone the images

   Copy

   SOURCE_REGISTRY="quay.io/devtron"
   TARGET_REGISTRY=${TARGET_REGISTRY}
   SOURCE_IMAGES_FILE_NAME="${SOURCE_IMAGES_FILE_NAME:=devtron-images.txt.source}"
   TARGET_IMAGES_FILE_NAME="${TARGET_IMAGES_FILE_NAME:=devtron-images.txt.target}"
   
   cp $SOURCE_IMAGES_FILE_NAME $TARGET_IMAGES_FILE_NAME
   while read source_image; do
     if [[ "$source_image" == *"workflow-controller:"* || "$source_image" == *"argoexec:"* || "$source_image" == *"argocd:"* ]]
     then
       SOURCE_REGISTRY="quay.io/argoproj"
       sed -i "s|${SOURCE_REGISTRY}|${TARGET_REGISTRY}|g" $TARGET_IMAGES_FILE_NAME
     elif [[ "$source_image" == *"redis:"* ]]
     then
       SOURCE_REGISTRY="public.ecr.aws/docker/library"
       sed -i "s|${SOURCE_REGISTRY}|${TARGET_REGISTRY}|g" $TARGET_IMAGES_FILE_NAME
     else
       SOURCE_REGISTRY="quay.io/devtron"
       sed -i "s|${SOURCE_REGISTRY}|${TARGET_REGISTRY}|g" $TARGET_IMAGES_FILE_NAME
     fi
   done <$SOURCE_IMAGES_FILE_NAME
   echo "Target Images file finalized"
   
   while read -r -u 3 source_image && read -r -u 4 target_image ; do
     echo "Pushing $source_image $target_image"
     podman manifest create $source_image
     podman manifest add $source_image $source_image --all
     podman manifest push $source_image $target_image --all
   done 3<"$SOURCE_IMAGES_FILE_NAME" 4<"$TARGET_IMAGES_FILE_NAME"

Devtron Installation

Before starting, ensure you have created an image pull secret for your registry if authentication is required.

1. Create the namespace (if not already created)

   Copy

   kubectl create ns devtroncd

2. Create the Docker registry secret

   Copy

   kubectl create secret docker-registry devtron-imagepull \
     --namespace devtroncd \
     --docker-server=$TARGET_REGISTRY \
     --docker-username=$TARGET_REGISTRY_USERNAME \
     --docker-password=$TARGET_REGISTRY_TOKEN

   If you are installing Devtron with the CI/CD module or using Argo CD, create the secret in the following namespaces else, you can skip this step-:

   Copy

   kubectl create secret docker-registry devtron-imagepull \
     --namespace devtron-cd \
     --docker-server=$TARGET_REGISTRY \
     --docker-username=$TARGET_REGISTRY_USERNAME \
     --docker-password=$TARGET_REGISTRY_TOKEN
   kubectl create secret docker-registry devtron-imagepull \
     --namespace devtron-ci \
     --docker-server=$TARGET_REGISTRY \
     --docker-username=$TARGET_REGISTRY_USERNAME \
     --docker-password=$TARGET_REGISTRY_TOKEN
   kubectl create secret docker-registry devtron-imagepull \
     --namespace argo \
     --docker-server=$TARGET_REGISTRY \
     --docker-username=$TARGET_REGISTRY_USERNAME \
     --docker-password=$TARGET_REGISTRY_TOKEN

3. Navigate to the Devtron Helm chart directory

   Copy

   cd charts/devtron

Install Devtron without any Integration

Use the below command to install Devtron without any Integrations

1. Without imagePullSecrets:

   Copy

   helm install devtron . -n devtroncd --set global.containerRegistry="$TARGET_REGISTRY"

2. With imagePullSecrets:

   Copy

   helm install devtron . -n devtroncd --set global.containerRegistry="$TARGET_REGISTRY" --set global.imagePullSecrets[0].name=devtron-imagepull

Installing Devtron with CI/CD Mode

Use the below command to install Devtron with only the CI/CD module

1. Without imagePullSecrets:

   Copy

   helm install devtron . -n devtroncd --set installer.modules={cicd} --set global.containerRegistry="$TARGET_REGISTRY"

2. With imagePullSecrets:

   Copy

   helm install devtron . -n devtroncd --set installer.modules={cicd} --set global.containerRegistry="$TARGET_REGISTRY" --set global.imagePullSecrets[0].name=devtron-imagepull

Install Devtron with CICD Mode including Argocd

Use the below command to install Devtron with the CI/CD module and Argo CD

1. Without imagePullSecrets:

   Copy

   helm install devtron . --create-namespace -n devtroncd --set installer.modules={cicd} --set argo-cd.enabled=true --set global.containerRegistry="$TARGET_REGISTRY" --set argo-cd.global.image.repository="${TARGET_REGISTRY}/argocd" --set argo-cd.redis.image.repository="${TARGET_REGISTRY}/redis"

2. With imagePullSecrets:

   Copy

   helm install devtron . --create-namespace -n devtroncd --set installer.modules={cicd} --set argo-cd.enabled=true --set global.containerRegistry="$TARGET_REGISTRY" --set argo-cd.global.image.repository="${TARGET_REGISTRY}/argocd" --set argo-cd.redis.image.repository="${TARGET_REGISTRY}/redis" --set global.imagePullSecrets[0].name=devtron-imagepull

Next Steps

After installation, refer Devtron installation documentation for further steps, including obtaining the dashboard URL and the admin password.

In this section, we describe on how you can install Helm Dashboard by Devtron without any integrations. Integrations can be added later using Devtron Stack Manager.

If you want to install Devtron on Minikube, Microk8s, K3s, Kind, refer this section.

Before you begin

Install Helm if you have not installed it.

Add Helm Repo

helm repo add devtron https://helm.devtron.ai

Update Helm Repo

helm repo update devtron

Install Helm Dashboard by Devtron

Note: This installation command will not install CI/CD integration. For CI/CD, refer install Devtron with CI/CD section.

Run the following command to install Helm Dashboard by Devtron:

helm install devtron devtron/devtron-operator \
--create-namespace --namespace devtroncd

Install Multi-Architecture Nodes (ARM and AMD)

To install Devtron on clusters with the multi-architecture nodes (ARM and AMD), append the Devtron installation command with --set installer.arch=multi-arch.

Devtron Dashboard

Run the following command to get the dashboard URL:

kubectl get svc -n devtroncd devtron-service -o jsonpath='{.status.loadBalancer.ingress}'

You will get the result something as shown below:

[test2@server ~]$ kubectl get svc -n devtroncd devtron-service -o jsonpath='{.status.loadBalancer.ingress}'
[map[hostname:aaff16e9760594a92afa0140dbfd99f7-305259315.us-east-1.elb.amazonaws.com]]

The hostname aaff16e9760594a92afa0140dbfd99f7-305259315.us-east-1.elb.amazonaws.com as mentioned above is the Loadbalancer URL where you can access the Devtron dashboard.

You can also do a CNAME entry corresponding to your domain/subdomain to point to this Loadbalancer URL to access it at a custom domain.

Devtron Admin credentials

When you install Devtron for the first time, it creates a default admin user and password (with unrestricted access to Devtron). You can use that credentials to log in as an administrator.

After the initial login, we recommend you set up any SSO service like Google, GitHub, etc., and then add other users (including yourself). Subsequently, all the users can use the same SSO (let's say, GitHub) to log in to Devtron's dashboard.

The section below will help you understand the process of getting the administrator credentials.

For Devtron version v0.6.0 and higher

Username: admin Password: Run the following command to get the admin password:

kubectl -n devtroncd get secret devtron-secret \
-o jsonpath='{.data.ADMIN_PASSWORD}' | base64 -d

kubectl -n devtroncd get secret devtron-secret \
-o jsonpath='{.data.ACD_PASSWORD}' | base64 -d

Note: If you want to uninstall Devtron or clean Devtron helm installer, refer our uninstall Devtron.

Upgrade

To use the CI/CD capabilities with Devtron, you can Install the Devtron with CI/CD or Devtron with CI/CD along with GitOps (Argo CD).

You can install and try Devtron on a high-end machine or a Cloud VM. If you install it on a laptop/PC, it may start to respond slowly, so it is recommended to uninstall Devtron from your system before shutting it down.

Prerequisites

1. 2 vCPUs

2. 4GB+ of free memory

3. 20GB+ free disk space

Before you get started, you must set up a cluster in your server and finish the following actions:

• Create a cluster using Minikube or Kind or K3s.

• Install Helm3.

• Install kubectl.

Tutorial

For Minikube, Microk8s, K3s, Kind

helm repo add devtron https://helm.devtron.ai

helm repo update devtron

helm install devtron devtron/devtron-operator \
--create-namespace --namespace devtroncd \
--set components.devtron.service.type=NodePort --set installer.arch=multi-arch

kubectl apply -f https://raw.githubusercontent.com/rancher/local-path-provisioner/master/deploy/local-path-storage.yaml

helm repo add devtron https://helm.devtron.ai

helm repo update devtron

helm install devtron devtron/devtron-operator \
--create-namespace --namespace devtroncd \
--set components.devtron.service.type=NodePort

Access Devtron Dashboard

To access Devtron dashboard when using Minikube as cluster, run the following command:

minikube service devtron-service --namespace devtroncd

To access Devtron dashboard when using Kind/k3s as cluster, run the following command to port forward the devtron service to port 8000:

kubectl -n devtroncd port-forward service/devtron-service 8000:80

Dashboard: http://127.0.0.1:8000.

Get Admin Credentials

When you install Devtron for the first time, it creates a default admin user and password (with unrestricted access to Devtron). You can use that credentials to log in as an administrator.

After the initial login, we recommend you set up any SSO service like Google, GitHub, etc., and then add other users (including yourself). Subsequently, all the users can use the same SSO (let's say, GitHub) to log in to Devtron's dashboard.

The section below will help you understand the process of getting the administrator credentials.

For Devtron version v0.6.0 and higher

Username: admin Password: Run the following command to get the admin password:

kubectl -n devtroncd get secret devtron-secret \
-o jsonpath='{.data.ADMIN_PASSWORD}' | base64 -d

kubectl -n devtroncd get secret devtron-secret \
-o jsonpath='{.data.ACD_PASSWORD}' | base64 -d

For Cloud VM (AWS EC2, Azure VM, GCP VM)

It is recommended to use Cloud VM with 2vCPU+, 4GB+ free memory, 20GB+ storage, Compute Optimized VM type & Ubuntu Flavoured OS.

Create Microk8s Cluster

sudo snap install microk8s --classic --channel=1.22
sudo usermod -a -G microk8s $USER
sudo chown -f -R $USER ~/.kube
newgrp microk8s
microk8s enable dns storage helm3
echo "alias kubectl='microk8s kubectl '" >> .bashrc
echo "alias helm='microk8s helm3 '" >> .bashrc
source .bashrc

Install Devtron

helm repo add devtron https://helm.devtron.ai

helm repo update devtron

helm install devtron devtron/devtron-operator \
--create-namespace --namespace devtroncd \
--set components.devtron.service.type=NodePort 

Get devtron-service Port Number

kubectl get svc -n devtroncd devtron-service -o jsonpath='{.spec.ports[0].nodePort}'

Make sure that the port on which the devtron-service runs remain open in the VM's security group or network security group.

Here we have demonstrated the installation of Devtron on popular cloud providers. The videos are easy to follow and provide step-by-step instructions.

Installing on EKS Cluster

Cloud Provider: Amazon Web Services (AWS)

Installing on AKS Cluster

Cloud Provider: Microsoft Azure

Installing on GKE Cluster

Cloud Provider: Google Cloud Platform (GCP)

In this section, we describe the steps in detail on how you can install Devtron with CI/CD integration.

Prerequisites

Install , if you have not installed it already.

Command

Run the following command to install the latest version of Devtron along with the CI/CD module:

Install Multi-Architecture Nodes (ARM and AMD)

To install Devtron on clusters with the multi-architecture nodes (ARM and AMD), append the Devtron installation command with --set installer.arch=multi-arch.

Configure Blob Storage during Installation

Configuring Blob Storage in your Devtron environment allows you to store build logs and cache. In case, if you do not configure the Blob Storage, then:

• You will not be able to access the build and deployment logs after an hour.

• Build time for commit hash takes longer as cache is not available.

• Artifact reports cannot be generated in pre/post build and deployment stages.

Choose one of the options to configure blob storage:

Check Status of Devtron Installation

Run the following command to check the status of the installation:

The command executes with one of the following output messages, indicating the status of the installation:

Check the Installer Logs

Run the following command to check the installer logs:

Devtron Dashboard

Run the following command to get the Devtron dashboard URL:

You will get an output similar to the example shown below:

Use the hostname aaff16e9760594a92afa0140dbfd99f7-305259315.us-east-1.elb.amazonaws.com (Loadbalancer URL) to access the Devtron dashboard.

Devtron Admin Credentials

When you install Devtron for the first time, it creates a default admin user and password (with unrestricted access to Devtron). You can use that credentials to log in as an administrator.

After the initial login, we recommend you set up any SSO service like Google, GitHub, etc., and then add other users (including yourself). Subsequently, all the users can use the same SSO (let's say, GitHub) to log in to Devtron's dashboard.

The sections below will help you understand the process of getting the administrator password.

For Devtron version v0.6.0 and higher

Username: admin Password: Run the following command to get the admin password:

You can configure Devtron by using configuration files. Configuration files are YAML files which are user-friendly. The configuration allows you to quickly roll back a configuration change if necessary. It also aids cluster re-creation and restoration.

There are two ways you can perform configurations while setting up Devtron dashboard:

You can also setup ingress while setting up Devtron dashboard. Refer for ingress setup.

Still facing issues, please reach out to us on .

To uninstall Devtron, run the following command:

This command will remove all the namespaces related to Devtron (devtroncd, devtron-cd, devtron-ci etc.).

Note: If you have questions, please let us know on our discord channel.

Overview

The Kubernetes client by Devtron is a very lightweight dashboard that can be installed on arm64/amd64-based architectures. It comes with the features such as Kubernetes Resources Browser and Cluster Management that can provide control and observability for resources across clouds and clusters.

Devtron Kubernetes client is an intuitive Kubernetes Dashboard or a command line utility installed outside a Kubernetes cluster. The client can be installed on a desktop running on any Operating Systems and interact with all your Kubernetes clusters and workloads through an API server. It is a binary, packaged in a bash script that you can download and install by using the following set of commands.

By installing Devtron Kubernetes Client, you can access:

Here are a few advantages of using Devtron Kubernetes Client:

• Managing Kubernetes Resources at scale: Clusters vary on business and architectural needs. Organizations tend to build smaller clusters for more decentralization. This practice leads to the creation of multiple clusters and more nodes. Managing them on a CLI requires multiple files, making it difficult to perform resource operations. But with the Devtron Kubernetes Client, you can gain more visibility into K8s resources easily.

• Unifying information in one place: When information is scattered across clusters, and you have to type commands with arguments to fetch desired output, the process becomes slow and error-prone. Without a single point of configuration source, the configurations of different config. files diverge, making them even more challenging to restore and track. The Devtron Kubernetes Client unifies all the information and tools into one interface to perform various contextual tasks.

• Accessibility during an outage for troubleshooting: As the Devtron Kubernetes Client runs outside a cluster, you can exercise basic control over their failed resources when there is a cluster-level outage. The Client helps to gather essential logs and data to pinpoint the root cause of the issue and reduce the time to restore service.

• Avoiding Kubeconfig version mismatch errors: With the Devtron Kubernetes Client, you can be relieved from maintaining the Kubeconfig versions for the respective clusters (v1.16 - 1.26 i.e, current version) as the Devtron Kubernetes Client performs self kubeconfig version control. Instead of managing multiple kubectl versions manually, it eliminates the chances of errors occurring due to the mismatch in configuration.

Install Devtron Kubernetes Client

• Download the bash script using the below URL: https://cdn.devtron.ai/k8s-client/devtron-install.bash

• To automatically download the executable file and to open the dashboard in the respective browser, run the following command:

Note: Make sure you place Devtron-install.bash in your current directory before you execute the command.

• Devtron Kubernetes Client opens in your browser automatically.

Note: You do not need to have a super admin permission to add a cluster if you install Devtron Kubernetes Client. You can add more than one cluster.

Kubernetes Resource Browser

Kubernetes Resource Browser provides a graphical user interface for interacting and managing all your Kubernetes (k8s) resources across clusters. It also helps you to deploy and manage Kubernetes resources and allows pod operations such as:

• View real-time logs

• Check manifest and edit live manifests of k8s resources

• Executable via terminal

• View Events

• Or, delete a resource

With Kubernetes Resource browser, you can also perform the following:

• Check the real-time health status

• Search for any workloads

• Manage multiple clusters and change cluster contexts

• Deploy multiple K8s manifests through Create UI option.

• Perform resource grouping at the cluster level.

Note: You do not need to have a super admin permission to access Kubernetes Resource Browser if you install Devtron Kubernetes Client.

Cluster Management

With the Devtron Kubernetes Client, you can manage all your clusters running on-premises or on a cloud. It is a cluster and cloud agnostic platform where you can add as many clusters as you want, be it a lightweight cluster such as k3s/ microk8s or cloud managed clusters like Amazon EKS.

It enables you to observe and monitor the cluster health and real-time node conditions. The Cluster management feature provides a summary of nodes with all available labels, annotations, taints, and other parameters such as resource usage. In addition to that, it helps you to perform node operations such as:

• Debug a node

• Cordon a node

• Drain a node

• Taint a node

• Edit a node config

• Delete a node

Some Peripheral Commands

• In case if you close the browser by mistake, you can open the dashboard by executing the following command. It will open the dashboard through a port in the available web browser and store the Kubernetes client's state.

• To stop the dashboard, you can execute the following command:

• To update the Devtron Kubernetes Client, use the following command. It will stop the running dashboard and download the latest executable file and open it in the browser.

In certain cases, you may want to override default configurations provided by Devtron. For example, for deployments or statefulsets you may want to change the memory or CPU requests or limit or add node affinity or taint tolerance. Say, for ingress, you may want to add annotations or host. Samples are available inside the directory.

To modify a particular object, it looks in namespace devtroncd for the corresponding configmap as mentioned in the mapping below:

apiVersion, kind, metadata.name in the multiline string is used to match the object which needs to be modified. In this particular case it will look for apiVersion: extensions/v1beta1, kind: Ingress and metadata.name: devtron-ingress and will apply changes mentioned inside update: as per the example inside the metadata: it will add annotations owner: app1 and inside spec.rules.http.host it will add http://change-me.

Once we have made these changes in our local system we need to apply them to a Kubernetes cluster on which Devtron is installed currently using the below command:

Run the following command to make these changes take effect:

Our changes would have been propagated to Devtron after 20-30 minutes.

Recommended Resources for Production use

The overall resources required for the recommended production overrides are:

The production overrides can be applied as pre-devtron installation as well as post-devtron installation in the respective namespace.

Pre-Devtron Installation

If you want to install a new Devtron instance for production-ready deployments, this is the best option for you.

Create the namespace and apply the overrides files as stated above:

After files are applied, you are ready to install your Devtron instance with production-ready resources.

Post-Devtron Installation

If you have an existing Devtron instance and want to migrate it for production-ready deployments, this is the right option for you.

In the existing namespace, apply the production overrides as we do it above.

A global configuration allows you to easily share common configuration between multiple repositories without copy/pasting it to these repositories.

Before you start creating an application, we recommend to provide basic information in different sections of Global Configurations available in Devtron.

You can also refer our YouTube video provided here.

Introduction

If you wish to use Ingress as a means to access the Devtron services available in your cluster, you can configure it either during the installation or after the installation of Devtron.

Refer the section relevant to you:

• During Devtron Installation

• After Devtron Installation

If you have successfully configured Ingress, refer Post Ingress Setup.

Enabling Ingress during Devtron Installation

If you are installing Devtron, you can enable Ingress either via set flag or by using ingress-values.yaml to specify the desired Ingress settings.

Using set flag

You can use the --set flag to specify the desired Ingress settings.

Here, we have added 5 configurations you can perform depending on your requirements:

• Only Basic Configuration

• Configuration Including Labels

• Configuration Including Annotations

• Configuration Including TLS Settings

• Comprehensive Configuration

Only Basic Configuration

To enable Ingress and set basic parameters, use the following command:

helm install devtron devtron/devtron-operator -n devtroncd \
  --set components.devtron.ingress.enabled=true \
  --set components.devtron.ingress.className=nginx \
  --set components.devtron.ingress.host=devtron.example.com

Configuration Including Labels

To add labels to the Ingress resource, use the following command:

helm install devtron devtron/devtron-operator -n devtroncd \
  --set components.devtron.ingress.enabled=true \
  --set components.devtron.ingress.className=nginx \
  --set components.devtron.ingress.host=devtron.example.com \
  --set components.devtron.ingress.labels.env=production

Configuration Including Annotations

To add annotations to the Ingress resource, use the following command:

helm install devtron devtron/devtron-operator -n devtroncd \
  --set components.devtron.ingress.enabled=true \
  --set components.devtron.ingress.className=nginx \
  --set components.devtron.ingress.host=devtron.example.com \
  --set components.devtron.ingress.annotations."kubernetes\.io/ingress\.class"=nginx \
  --set components.devtron.ingress.annotations."nginx\.ingress\.kubernetes\.io\/app-root"="/dashboard"

Configuration Including TLS Settings

To configure TLS settings, including secretName and hosts, use the following command:

helm install devtron devtron/devtron-operator -n devtroncd \
  --set components.devtron.ingress.enabled=true \
  --set components.devtron.ingress.className=nginx \
  --set components.devtron.ingress.host=devtron.example.com \
  --set components.devtron.ingress.tls[0].secretName=devtron-tls \
  --set components.devtron.ingress.tls[0].hosts[0]=devtron.example.com

Comprehensive Configuration

To include all the above settings in a single command, use:

helm install devtron devtron/devtron-operator -n devtroncd \
  --set components.devtron.ingress.enabled=true \
  --set components.devtron.ingress.className=nginx \
  --set components.devtron.ingress.host=devtron.example.com \
  --set components.devtron.ingress.annotations."kubernetes\.io/ingress\.class"=nginx \
  --set components.devtron.ingress.annotations."nginx\.ingress\.kubernetes\.io\/app-root"="/dashboard" \
  --set components.devtron.ingress.labels.env=production \
  --set components.devtron.ingress.pathType=ImplementationSpecific \
  --set components.devtron.ingress.tls[0].secretName=devtron-tls \
  --set components.devtron.ingress.tls[0].hosts[0]=devtron.example.com

Using ingress-values.yaml

As an alternative to the set flag method, you can enable Ingress using ingress-values.yaml instead.

Create an ingress-values.yaml file. You may refer the below format for an advanced ingress configuration which includes labels, annotations, secrets, and many more.

components:
  devtron:
    ingress:
      enabled: true
      className: nginx
      labels: {}
        # env: production
      annotations: {}
        # nginx.ingress.kubernetes.io/app-root: /dashboard
      pathType: ImplementationSpecific
      host: devtron.example.com
      tls: []
    #    - secretName: devtron-info-tls
    #      hosts:
    #        - devtron.example.com

Once you have the ingress-values.yaml file ready, run the following command:

helm install devtron devtron/devtron-operator -n devtroncd  --reuse-values  -f ingress-values.yaml

Configuring Ingress after Devtron Installation

After Devtron is installed, Devtron is accessible through devtron-service. If you wish to access Devtron through ingress, you'll need to modify this service to use a ClusterIP instead of a LoadBalancer.

You can do this using the kubectl patch command:

kubectl patch -n devtroncd svc devtron-service -p '{"spec": {"ports": [{"port": 80,"targetPort": "devtron","protocol": "TCP","name": "devtron"}],"type": "ClusterIP","selector": {"app": "devtron"}}}'

Next, create ingress to access Devtron by applying the devtron-ingress.yaml file. The file is also available on this link. You can access Devtron from any host after applying this yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations: 
    nginx.ingress.kubernetes.io/app-root: /dashboard
  labels:
    app: devtron
    release: devtron
  name: devtron-ingress
  namespace: devtroncd
spec:
  ingressClassName: nginx
  rules:
  - http:
      paths:
      - backend:
          service:
            name: devtron-service
            port:
              number: 80
        path: /orchestrator
        pathType: ImplementationSpecific 
      - backend:
          service:
            name: devtron-service
            port:
              number: 80
        path: /dashboard
        pathType: ImplementationSpecific
      - backend:
          service:
            name: devtron-service
            port:
              number: 80
        path: /grafana
        pathType: ImplementationSpecific  

For k8s versions < 1.19, apply this yaml:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  annotations: 
    nginx.ingress.kubernetes.io/app-root: /dashboard
  labels:
    app: devtron
    release: devtron
  name: devtron-ingress
  namespace: devtroncd
spec:
  rules:
  - http:
      paths:
      - backend:
          serviceName: devtron-service
          servicePort: 80
        path: /orchestrator
      - backend:
          serviceName: devtron-service
          servicePort: 80
        path: /dashboard
        pathType: ImplementationSpecific  

Optionally, you also can access Devtron through a specific host by running the following YAML file:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  annotations: 
    nginx.ingress.kubernetes.io/app-root: /dashboard
  labels:
    app: devtron
    release: devtron
  name: devtron-ingress
  namespace: devtroncd
spec:
  ingressClassName: nginx
  rules:
    - host: devtron.example.com
      http:
        paths:
          - backend:
              service:
                name: devtron-service
                port:
                  number: 80
            path: /orchestrator
            pathType: ImplementationSpecific
          - backend:
              service:
                name: devtron-service
                port:
                  number: 80
            path: /dashboard
            pathType: ImplementationSpecific
          - backend:
              service:
                name: devtron-service
                port:
                  number: 80
            path: /grafana
            pathType: ImplementationSpecific

Enable HTTPS For Devtron

Once Ingress setup for Devtron is done and you want to run Devtron over https, you need to add different annotations for different ingress controllers and load balancers.

1. Nginx Ingress Controller

In case of nginx ingress controller, add the following annotations under service.annotations under nginx ingress controller to run devtron over https.

(i) Amazon Web Services (AWS)

If you are using AWS cloud, add the following annotations under service.annotations under nginx ingress controller.

  annotations:
    service.beta.kubernetes.io/aws-load-balancer-backend-protocol: "http"
    service.beta.kubernetes.io/aws-load-balancer-ssl-ports: "443"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
    service.beta.kubernetes.io/aws-load-balancer-ssl-cert: "<acm-arn-here>"

(ii) Digital Ocean

If you are using Digital Ocean cloud, add the following annotations under service.annotations under nginx ingress controller.

annotations:
  service.beta.kubernetes.io/do-loadbalancer-protocol: "http"
  service.beta.kubernetes.io/do-loadbalancer-tls-ports: "443"
  service.beta.kubernetes.io/do-loadbalancer-certificate-id: "<your-certificate-id>"
  service.beta.kubernetes.io/do-loadbalancer-redirect-http-to-https: "true"

2. AWS Application Load Balancer (AWS ALB)

In case of AWS application load balancer, add following annotations under ingress.annotations to run devtron over https.

  annotations:
    kubernetes.io/ingress.class: alb
    alb.ingress.kubernetes.io/listen-ports: '[{"HTTP": 80}, {"HTTPS": 443}]'
    alb.ingress.kubernetes.io/certificate-arn: "<acm-arn-here>"

3. Azure Application Gateway

In case of AWS application load balancer, the following annotations need to be added under ingress.annotations to run devtron over https.

 annotations:
  kubernetes.io/ingress.class: "azure/application-gateway"
  appgw.ingress.kubernetes.io/backend-protocol: "http"
  appgw.ingress.kubernetes.io/ssl-redirect: "true"
  appgw.ingress.kubernetes.io/appgw-ssl-certificate: "<name-of-appgw-installed-certificate>"

For an Ingress resource to be observed by AGIC (Application Gateway Ingress Controller) must be annotated with kubernetes.io/ingress.class: azure/application-gateway. Only then AGIC will work with the Ingress resource in question.

Note: Make sure NOT to use port 80 with HTTPS and port 443 with HTTP on the Pods.

Authorization section describes how to authenticate and authorize access to resources, also managing role-based access levels in Devtron.

Access can be granted to a user via:

• SSO Login Services

• User Permissions

• Permission Groups

• API Tokens

Configure Secrets

For Helm installation this section refers to secrets section of values.yaml.

Configure the following properties:

Configure ConfigMaps

For Helm installation this section refers to configs section of values.yaml.

Configure the following properties:

Configure Resources

Devtron provides ways to control how much memory or CPU can be allocated to each Devtron microservice. You can adjust the resources that are allocated to these microservices based on your requirements. The resource configurations are available in following sizes:

Small: To configure the small resources (e.g. to manage less than 10 apps on Devtron ) based on the requirements, append the Devtron installation command with -f https://raw.githubusercontent.com/devtron-labs/devtron/main/charts/devtron/resources-small.yaml.

Configure Overrides

For Helm installation this section refers to customOverrides section of values.yaml. In this section you can override values of devtron-cm which you want to keep persistent. For example:

You can configure the following properties:

Storage for Logs and Cache

AWS SPECIFIC

While installing Devtron and using the AWS-S3 bucket for storing the logs and caches, the below parameters are to be used in the ConfigMap.

NOTE: For using the S3 bucket it is important to add the S3 permission policy to the IAM role attached to the nodes of the cluster.

The below parameters are to be used in the Secrets :

AZURE SPECIFIC

While installing Devtron using Azure Blob Storage for storing logs and caches, the below parameters will be used in the ConfigMap.

GOOGLE CLOUD STORAGE SPECIFIC

While installing Devtron using Google Cloud Storage for storing logs and caches, the below parameters will be used in the ConfigMap.