Forem: Akanksha Bhasin

Devtron Year in Review 2024

Akanksha Bhasin — Sun, 05 Jan 2025 07:51:42 +0000

2024 was a breakout year! As we close the 2024 chapter, we reflect on a remarkable year of growth, innovation and collaboration. This year has been filled with exciting milestones, impactful product updates and meaningful engagements with our global community. From receiving prestigious recognitions from AWS, surpassing new heights on GitHub to connecting with the cloud-native community at events worldwide, 2024 has been a year of impact and progress.

🚀 Key Product Updates

This year, we delivered features to address challenges faced by developers and DevOps teams and simplify Kubernetes management for faster, more secure deployments:

Application Deployment & Distribution:
- The new Software Distribution Hub centralizes management for microservices delivery across multiple customers and including air-gapped environments.
- Deployment windows (Blackout & Maintenance windows) were introduced to control deployments and avoid disruptions.
- Approval Groups enforce robust governance and Runtime Input Parameters provide dynamic CI/CD control.
Streamlined Configuration:
- Compare Configuration across environments to prevent drift, Clone CI/CD Workflows, and lock configurations for enhanced security and consistency. Build Infrastructure Configurations for optimized resource utilization.
Cluster Management:
- Minimizing downtime and MTTR using Auto Remediation and reducing manual intervention and faster error resolution. Simplify Kubernetes upgrades with automated compatibility checks using Silver Surfer
- GitOps Listing: Visualize multi-cluster ArgoCD & FluxCD applications for unified management.
Enhanced Security:
- Secure kubectl access providing developers with controlled terminal access using fine-grained RBAC API tokens.
- User Access Management with SSO mapping for simplified administration.
Intelligence & Monitoring:
- Devtron Intelligence (AI-powered error analysis) and centralized dashboards (Grafana, Kibana integration) for a single pane of glass view.

🏊 Dive deeper into a detailed version of product updates from 2024 now.

🌟 A Special Highlight - The launch of Devtron 1.0, a major milestone that transforms Kubernetes operations for enterprises using AI. Unveiled at KubeCon North America, Devtron 1.0 brings powerful new features like AI-driven troubleshooting, enhanced CI/CD workflows, auto-remediation, and robust RBAC to simplify Kubernetes management at scale. This release signifies a leap forward in DevOps automation, offering enterprises a unified platform for managing the entire application lifecycle and ensuring faster, more secure deployments.

🔗 Read more about it here.

🌟 Notable Achievements in 2024 🌟

2024 had been a great year for Devtron. With loads of new users, feedback, features, product enhancement, and community empowerment, the year had been filled with learning and fun.

🏆 Recognition from AWS

A standout moment for us was winning the AWS Rising Star Award (India) and being recognized as a finalist for APJ Technology Partner of the Year, a testament to our commitment to delivering solutions that simplify Kubernetes adoption while driving innovation in cloud-native application management.

AWS Partner Spotlight - Devtron

We highlighted the collaboration between Devtron and AWS, showcasing how our joint solutions streamline Kubernetes management on Amazon EKS.

Checkout this blog and explore how Devtron's powerful DevOps automation platform, integrated with AWS, helps teams improve development efficiency, accelerate software delivery and optimize costs.

🌍 Conferences

Devtron made its mark at several global conferences, connecting with the cloud-native community including AWS re:Invent, KubeCon North America, KubeCon India, US Fintech Symposium, KCD Hyderabad, KCD Washington DC, KCD Kerala, Cloud Native Rejekts, Dine with DevOps and DevOps Conclave & Awards.

👥 Events

We have hosted and participated in various industry-leading events including:

KubeCon India Networking Dinner

With the first ever KubeCon in India this year, we planned an exclusive KubeCon India networking dinner party post-conference on Day 1 in collaboration with Middleware. We welcomed around 180 folks at the event joining us from different parts of the world. We saw over 500+ professionals including founders, managers and DevOps Engineers signing in a short period. 🎉

The attendees exchanged valuable insights over discussions in the Cloud Native ecosystem and enjoyed the most happening DJ night in the town. 🪩

Top Golf Events

We had a great time hosting Top Golf Events at the United States in Atlanta, Austin and Dallas and inviting Kubernetes Practitioners. They enjoyed exchanging insights on Kubernetes strategies, and basking in an evening filled with good food, drinks and a great company.

Webinar with the AWS team & more

Enhancing DevOps Efficiency on Amazon EKS with Devtron - This webinar provided a comprehensive overview of how Devtron simplifies the deployment, management and scaling of Kubernetes applications on Amazon EKS, enabling teams to streamline operations and focus on building.

🔗 Tune in to watch our previous webinars here.

🗣️ Meetups:

Quite an eventful year I would say! We hosted meetups every month across India in Delhi NCR and Bangalore and partnered with organisations and CNCF communities and covered various topics including Kubernetes Cost Optimization, Observability, Software delivery, Platform Engineering, App Modernisation, Containerization, Cloud and more.

Follow our meetup page to stay updated on all the meetups and webinars we host. Do check out some of our past meetups that we have hosted.

We also expanded our footprint with meetups in the U.S. (at Austin, Virginia & Denver). Our team also attended & presented at various meetups across India, some of the notable ones include the KubernTENes Birthday bash meetup celebrating a decade of Kubernetes, DevOps Days, AWS Community Days, GitHub Constellation, GitTogether and more that fostered cloud-native collaborations.

❤️ Community Growth

Reached an incredible 10k+ followers on Linkedin and 4.6k GitHub Stars, a huge thanks to our growing community for the support and love. These valuable connections & conversations are not just memories; they are the building blocks that are guiding our strategic vision for the year ahead.

🎯 Looking Ahead

As we move into 2025, we remain committed to empowering teams with tools that simplify Kubernetes management and accelerate development cycles. With your support, we’re excited to continue this Cloud Native journey of innovation and community building.

Here’s to another incredible year ahead together, let’s redefine what’s possible in the cloud-native world. 🚀

KubeCon India 2024 Recap

Akanksha Bhasin — Thu, 26 Dec 2024 05:30:51 +0000

KubeCon has always been a significant event in the cloud-native ecosystem. After a long journey, India finally had its first KubeCon in Delhi on the 11th and 12th of December. After a long wait, KubeCon was finally organized in India, giving the Indian community an amazing opportunity to attend a KubeCon and network with some of the amazing folks within the industry. India is among the top five countries with the most active contributors, and this number is rapidly growing.

KubeCon India was a remarkable experience, and there were a lot of key takeaways that team Devtron had from the event. Let’s dive into all of the new announcements and learnings from KubeCon India.

Keynote Highlights

The event started with the iconic KubeCon keynotes. The Day 1 keynotes focused on sharing the amazing scaling power of Kubernetes and highlighted the entire Kubernetes journey from its origin, to where it is today, and what is to come. The Day 2 Keynotes focused more on the role of AI in the Kubernetes ecosystem, and the two technologies will continue to integrate. Let’s take a quick recap of the themes that were being discussed.

Service Mesh Adoption at Scale: Purushotham Malipedda and I V Prasad Reddy from Flipkart, one of India’s largest E-commerce websites, took to the stage to explain their journey of adopting a service mesh. They were facing challenges with scaling their workloads and implementing disaster recovery mechanisms. They onboarded Istio and migrated around 6,000 services, giving them the ability to leverage the mesh’s features such as service graphs and securing east-west traffic.
The Cloud Native Story: Nikhita Raghunath from VMware in her keynote walked through the entire journey of Kubernetes and cloud-native, and how it has evolved over the years. From the creation of the first containers to Kubernetes and where it has evolved from there. We’ve moved over to a standardized container runtime i.e. CRI, and even have the WASM runtime. Kubernetes has matured into a stable technology that folks are beginning to adopt. Nikita shared that the next few years of Kubernetes are going to be all-around optimization, from cost to performance, as well as improving the multi-cloud strategy.
The Unison of Cloud Native and AI: During the Keynotes of Day 2, AI was all the hype. Aparna Subramanian and Sumedh Degaonkar from Shopify talked about how they searched and found Kubernetes to be the perfect orchestration tool for deploying their AI and ML workloads. Arun Gupta from Intel walked through CNCF’s AI Working Group and talked about the entire cloud native AI landscape and how it’s evolving. Finally, Janakiram talked about how they orchestrated AI agents in Kubernetes using the built-in Kubernetes properties such as CustomResourceDefinitions, StatefulSets, and HorizontalPodAutoscalers.

[Fig.1] Keynote Sessions

Recommended Sessions to Watch

KubeCon India had a plethora of talks on AI, WASM, Operational optimization, and much more. While there was a ton of information to learn from the talks, a few stood out. We recommend rewatching some of the following talks once they are out.

How a Small Step turned into a Giant Leap to Cloud Native Adoption for an Enterprise: Ashwin Gupta and Shubham Bansal, from Fidelity share their entire journey on how they adopted the cloud and cloud-native technologies. Initially, they started using open-source technologies and now, they have an entire stack of OSS tools from Kubernetes, Argo, Elastic, Helm, Cilium, and many more. This talk highlights all of the challenges that global financially regulated organizations can face when adopting Open Source technologies and the learnings Fidelity had along the way,
Optimizing 5G Networks: Deploying AI/ML Workloads with AIMLFW of O-RAN SC: Subash Kumar Singh from Samsung explored the AI/ML Framework (AIMLFW) within O-RAN SC (O-RAN Software Community) community. It was designed for dynamic and efficient 5G network management. This talk covered some of the core challenges in AI/ML workflows for distributed 5G networks, and how to overcome them.
Ensuring Seamless Service Continuity in 5G: Enhancing Kubernetes Disaster Recovery in Telecom: Ganesh Chandrasekaran and Saurabh Swaraj from Samsung’s R&D department highlighted the importance of having proper service availability in the telecom industry and the importance of making local and geographic redundancy for disaster recovery. This session explores a Kubernetes native solution to bridge the gap between existing tools such as Velero, Portworx, and Stash and offer seamless redundancy for telecom workload. This talk walks through some CNCF projects including Nephio for intent-based automation and Prometheus for real-time Monitoring in the Telco space.
Is GitOps a Broken Experience? Where’s the Ops in GitOps?: Rajalakshmi Kamath V from VMWare delved into the limitations of GitOps in large-scale Kubernetes environments. The talk focused on GitOps’ inability to provide real-time visibility into the actual state of the system or immediate operational control during outages. Drawing from Walmart’s experience managing over 200,000 workloads and 10,000 daily deployments across thousands of clusters, the session highlighted the need for complementary operational tools. These tools enhance observability and runtime state insights, bridging critical gaps in GitOps workflows and ensuring greater resilience and efficiency in managing Kubernetes workloads.
Scaling Private LLM Model Services with Kserve and Modelcar OCI: A Real-World Implementation: Mayuresh Krishna from Initializ highlighted how Kubernetes, Kserve, and Modelcar OCI storage simplify the deployment and scaling of private LLM services. The talk addressed the challenges of complexity and cost and demonstrated how Kserve enables efficient, scalable model serving with optimized GPU utilization and how Modelcar OCI artifacts streamline artifact delivery by reducing duplicate storage, enhancing download speeds, and minimizing governance overhead.
GenAI Recipes for Cloud Native Deployment: Arun Gupta and Kaushal Desai introduced OPEA, the Open Platform for Enterprise AI, that provides a framework of composable microservices for deploying GenAI applications. It showcased the process for deploying systems like ChatQnA, CodeGen, and RAG on Kubernetes across various Cloud Providers. The session showed the use of diverse data stores, including open-source vector databases and managed services, and highlighted scale testing with over 50,000 documents.
Faster Deployments at PepsiCo with Self-SErvice Continuous Delivery using the App of Apps Pattern: Chaitanya and Prasanti Kadiyala from PepsiCo transitioned to the GitOps methodology using ArgoCD for streamlining the deployment workflows. They leveraged ArgoCD's App of Apps pattern, to define a bootstrapper Application, enabling the automation of application deployment which allowed them to achieve self-service Continuous Delivery, empowering teams to independently manage their deployments while maintaining centralized control and visibility. This talk highlights the various challenges while adopting GitOps including managing dependencies, configuring environments and ensuring consistency across deployments.

Devtron at KubeCon India

[Fig.2] Team Devtron at KubeCon India

The Devtron team had attended KubeCon India, with high spirits and a secret plan in the works. During the main conference, we had some amazing conversations with folks who have been involved in the tech and cloud-native landscape for decades. Some of the memorable conversations we had have been around Platform Engineering, Kubernetes Challenges, WASM, Observability, and how the cloud-native landscape has evolved over the past couple of years.

Close to the end of the first day of the event, Devtron’s secret plan had begun execution. We organized a memorable networking party with our friends at Middleware. It was an evening full of insightful industry conversations, where founders, engineering managers, and Kubernetes experts from various companies came together over dinner to exchange ideas and foster new connections. Later we threw a DJ night and it was the most happening party in the town ever!

Here are some pictures to help attendees relive the excitement, and for folks who couldn’t make it, we hope to see you at the next KubeCon.

Conversations with Industry Veterans

In the two exciting days of KubeCon, we were also able to interview some people who are working on some groundbreaking technologies and who have been involved in the landscape for years to ask them their thoughts on where the industry is headed as a whole.

Please check out our YouTube channel to hear our conversations and gain insights into the direction of Kubernetes and cloud-native.

See you all at our next event!

Best 5 Alternatives to Kubernetes Dashboard

Akanksha Bhasin — Wed, 30 Oct 2024 17:23:44 +0000

While Kubernetes excels at scaling and operating systems efficiently, at larger scales the complexities of Kubernetes hamper the operational efficiency of teams. Key challenges emerge when organizations manage multiple clusters across regions, primarily relying on traditional command-line tools like kubectl. The absence of comprehensive visibility and frequent context switching between clusters for routine tasks significantly impacts productivity, making cluster management increasingly challenging at scale.

To eliminate the operational challenges of Kubernetes and provide an ease of managing Kubernetes clusters the Kubernetes dashboard was introduced. The Kubernetes dashboard is a web-based interface for managing your Kubernetes clusters. The Kubernetes dashboard provides a visual overview of your Kubernetes clusters and their workloads. You can use the Kubernetes dashboard to deploy containerized applications, troubleshoot your containerized applications, and manage the cluster resources. To read more about the Kubernetes dashboard refer to this blog.

In this blog, we will discuss powerful alternatives to the Kubernetes dashboard and examine their features and capabilities.

Why to Look for Alternatives to Kubernetes Dashboard

The default Kubernetes dashboard offers basic visualization and operational capabilities for infrastructure management. However, it falls short of being a comprehensive Kubernetes management solution. Some of the key limitations of the default Kubernetes dashboard are:

Limited Multi-Cluster Management : The default Kubernetes dashboard is designed to manage single clusters, making it inefficient for organizations running multiple clusters across different regions. Teams need a unified view to manage and monitor all clusters from a single interface.
Lack of Advanced Analytics : The native dashboard provides basic metrics and visualization capabilities, lacking advanced analytics, and detailed insights needed for effective resource optimization and troubleshooting at scale.
Limited Access Management Support : The dashboard does not provide a user-friendly way to implement fine-grained RBAC policies. Even with a Kubernetes dashboard, you need to manage robust RBAC through complex CLI tools.
Limited Dashboard Functionality : The default Kubernetes dashboard provides basic cluster visualization and simple operations but lacks advanced features like real-time monitoring, robust troubleshooting tools, and integrated logging capabilities, requiring administrators to use multiple external tools for comprehensive cluster management.

Alternatives to Kubernetes Dashboard

1. Devtron

Devtron’s Kubernetes dashboard is a modern Kubernetes management platform that provides operational efficiency over multiple Kubernetes clusters. The Devtron’s Kubernetes dashboard provides 360-degree visibility for the resources of your multiple Kubernetes clusters. Along with the visibility the dashboard provides capabilities like taking actions like visualizing and editing live Manifests, checking Events, and Logs, and a dedicated Terminal for debugging specific pods, which helps teams in troubleshooting tasks.

When it comes to managing access to your multiple Kubernetes clusters, Devtron’s Kubernetes dashboard simplifies the RBAC and provides you with the capability to configure robust and fine-grained access control through an intuitive UI. Devtron also provides support for seven SSOs to facilitate access to your Kubernetes infrastructure.

Devtron's Kubernetes dashboard extends its capabilities with comprehensive application management across Kubernetes clusters. Devtron comes with an in-built marketplace for Helm applications that streamlines the configuration and deployment of Helm applications. Beyond Helm support, Devtron provides unified visibility for applications deployed through tools like ArgoCD and FluxCD applications, offering a centralized view of all applications running within specific Kubernetes clusters.

Overview:

Multi-Cluster Operations Hub - Centralized dashboard providing 360-degree visibility and operational control across multiple Kubernetes clusters, enabling efficient management of distributed infrastructure from a single platform.
Advanced Troubleshooting Suite - Comprehensive debugging features like live manifest visualization/editing, event monitoring, real-time log streaming, and integrated pod terminal access for quick problem resolution.
Enterprise-Grade Access Control - Simplified RBAC management through intuitive UI with fine-grained access control capabilities and support for seven SSO providers, making Kubernetes infrastructure access both secure and convenient.
Unified Application Management - Built-in Helm marketplace for streamlined application deployment, plus integrated visibility for GitOps tools (ArgoCD, FluxCD), providing centralized control over all applications across clusters.

Streamline your Kubernetes workflow with Devtron's intuitive dashboard and check out their GitHub repository to get started.

2. OpenLens

OpenLens is an open-source distribution of the popular Lens IDE. It’s specifically tailored for those who want the Lens experience but with more flexibility and less vendor lock-in. OpenLens is lightweight, user-friendly, and provides a powerful visual interface for managing Kubernetes clusters. OpenLens focuses on providing a streamlined experience, making it easier to manage and troubleshoot clusters without the overhead.

OpenLens focuses on providing a simpler, more streamlined experience, making it a good choice for those who prefer a more lightweight tool without sacrificing power.

Overview:

Multi-Cluster Management - Unified view and management of multiple K8s clusters through a single pane of glass. Which enables teams to perform quick switches between clusters and consolidated monitoring across your entire K8s infrastructure.
Real-Time Resource Visualization - Interactive graphical displays of pod status, resource usage, and cluster metrics with drill-down capabilities for detailed analysis of containers, logs, and events in real-time
Built-in Terminal Access - Direct terminal access to containers and nodes from within the UI, allowing quick debugging and troubleshooting without needing to switch between tools or use kubectl commands separately.

3. Skooner

Skooner (formerly K8Dash) is a web-based Kubernetes dashboard that offers a clean and straightforward interface for managing your clusters. It’s designed to be fast and intuitive, making it a great choice for teams that need a simple yet powerful tool. Skooner keeps things simple, focusing on what matters most—efficient cluster management.

Skooner shines when you need a quick and easy way to monitor and manage your Kubernetes clusters without getting bogged down in complex features.

*Overview: *

Resource-Centric Navigation - Skooner provides an Intuitive navigation capability around K8s resources (pods, services, deployments) with quick filters and search capabilities that make it easier for you to find and manage specific components in large Kubernetes clusters.
Live Health Monitoring - Real-time health status indicators for all resources with visual alerts for issues, enabling you to quickly spot and respond to problems across namespaces and resource types.
Lightweight & Fast Interface - Minimalist, performance-focused design that loads and updates quickly even with large clusters, making it more responsive than the default dashboard for day-to-day operations.

4. Headlamp

Headlamp is another excellent alternative to the default Kubernetes dashboard, offering a more developer-centric approach to Kubernetes management. It’s open-source, with a focus on providing a great user experience for those working directly with Kubernetes. Headlamp is particularly well-suited for development teams who need quick access to the details of their clusters without dealing with the complexities of the CLI tool.

Headlamp offers a clean and intuitive UI, providing a refreshing alternative that’s easier to navigate.

Overview:

Developer-Focused - Designed with developers in mind, offering quick access to necessary tools.
Multi-Cluster Management - Seamless handling of multiple clusters with easy switching and unified view, while maintaining separate contexts and configurations for each cluster.
Resource Editing & Management - Direct YAML editing and updating of Kubernetes resources through the UI, with validation and preview capabilities before applying changes to prevent configuration errors.

5. Octant

Octant is a highly visual, open-source tool designed for inspecting and understanding Kubernetes clusters. It’s particularly strong in providing insights into what’s happening within your clusters, making it a valuable tool for debugging and troubleshooting. Octant offers a more in-depth view of your Kubernetes environment compared to the default Kubernetes dashboard.

Overview:

Plugin Extensibility - Built-in plugin system supporting integration with tools like Helm, Starboard, and Knative, allowing developers to extend functionality beyond basic Kubernetes operations based on their needs.
Resource Viewer & Navigation - Comprehensive view of workloads and resources within namespaces, with filtering capabilities and real-time status updates of applications, making it easier to monitor and manage Kubernetes cluster resources.

Conclusion

While the default Kubernetes dashboard provides a basic interface for managing Kubernetes clusters, its limitations in multi-cluster management, advanced analytics and role-based access control. Tools like Devtron, OpenLens, Skooner, Headlamp and Octant offer enhanced capabilities that address these shortcomings, providing users with improved visibility, streamlined operations, and better troubleshooting features. By adopting these alternatives, organizations can significantly enhance their operational efficiency and effectively manage their Kubernetes environments at scale.

Additional Resources to Read

If you have any questions, or want to discuss any specific usecase, feel free to connect with us or ask them in our actively growing Discord Community.

Happy Deploying!

12 Tools to make Kubernetes management easier in 2024

Akanksha Bhasin — Mon, 12 Aug 2024 15:55:15 +0000

Kubernetes, the revolutionary container orchestration platform, has empowered developers to build, deploy, and scale applications with unparalleled flexibility and efficiency for a decade. But let's be honest, Kubernetes' sheer scale and complexity can sometimes feel overwhelming, even for seasoned DevOps engineers. You're still battling tangled deployments, resource conflicts, and security concerns frequently. Developers may face distractions from core application development due to manual operational tasks and the steep learning curve.

But fear not, Intrepid CloudNative Warriors! This blog post is your guide to navigating the intricate world of Kubernetes with ease. We'll explore 12 essential tools that streamline workflows, boost efficiency, and make managing your Kubernetes management easier in 2024.

But Wait! Why Simplify Kubernetes - Management?

Let's face it, modern applications are demanding. You're juggling containerized workloads, scaling for peak usage, and ensuring everything runs smoothly. This is where efficient management tools come in, offering these crucial benefits:

Reduced Complexity: No more wrestling with Kubectl commands or endless configuration files. These tools offer intuitive interfaces and automated processes that make your life easier.
Increased Efficiency: Let's be real, you're a busy person. These tools automate repetitive tasks and streamline workflows, freeing you up to focus on problem-solving & innovation.
Enhanced Security: Security is non-negotiable. Dedicated security tools proactively scan for vulnerabilities, enforce policies, and help you keep your applications and infrastructure safe from harm.
Improved Cost Optimization: You want to make the most of your resources and cost analyzers and autoscale help you optimize resource utilization, preventing over-provisioning and saving you money.

Now that we've recognized the significance, let's delve into 12 essential tools that streamline Kubernetes management.

1. KEDA

Keda (Kubernetes Event-Driven Autoscaling) is an event-driven autoscale for Kubernetes workloads. Simply defined, it can scale an application based on the number of events needing to be handled.

Installing KEDA

KEDA has well-documented steps for installation in their documentation. You can install it with Helm, Operator Hub, or YAML declarations. In this blog, let's go with the helm.

Step 1: Add Helm Repo

helm repo add kedacore https://kedacore.github.io/charts

Step 2: Update Helm Repo

helm repo update

Step 3: Install KEDA in keda Namespace

helm install keda kedacore/keda --namespace keda --create-namespace

Use Cases

KEDA is a classic example of autoscaling based on different metrics. When you want to autoscale your application beyond the resource metrics like CPU/ Memory, you can use KEDA. It listens to specific events such as messages from message queues, HTTP requests, custom Prometheus metrics, Kafka lag, etc. To deep dive into KEDA, check out this blog.

2. Karpenter

Built in AWS, Karpenter is a high-performance, flexible, open-source Kubernetes cluster auto-scaler. One of its key features is the ability to launch EC2 instances based on specific workload requirements such as storage, compute, acceleration, and scheduling needs.

Installation

Install Karpenter in the Kubernetes cluster using Helm charts. But before doing this, you must ensure enough computing capacity is available. Karpenter requires permissions to provision compute resources that are based on the cloud provider you have chosen.

Step 1: Install Utilities

Karpenter can be installed in clusters using a Helm chart. Install these tools before proceeding:

AWS CLI
kubectl - the Kubernetes CLI
eksctl (>= v0.180.0) - the CLI for AWS EKS
helm - the package manager for Kubernetes

Configure the AWS CLI with a user that has sufficient privileges to create an EKS cluster. Verify that the CLI can authenticate properly by running aws sts get-caller-identity.

Step 2: Set Environment Variables

After installing the dependencies, set the Karpenter namespace, version and Kubernetes version as follows.

export KARPENTER_NAMESPACE="kube-system"
export KARPENTER_VERSION="0.37.0"
export K8S_VERSION="1.30"

Then set the following environment variables which would be further used for creating an EKS cluster.

export AWS_PARTITION="aws" # if you are not using standard partitions, you may need to configure to aws-cn / aws-us-gov
export CLUSTER_NAME="${USER}-karpenter-demo"
export AWS_DEFAULT_REGION="us-west-2"
export AWS_ACCOUNT_ID="$(aws sts get-caller-identity --query Account --output text)"
export TEMPOUT="$(mktemp)"
export ARM_AMI_ID="$(aws ssm get-parameter --name /aws/service/eks/optimized-ami/${K8S_VERSION}/amazon-linux-2-arm64/recommended/image_id --query Parameter.Value --output text)"
export AMD_AMI_ID="$(aws ssm get-parameter --name /aws/service/eks/optimized-ami/${K8S_VERSION}/amazon-linux-2/recommended/image_id --query Parameter.Value --output text)"
export GPU_AMI_ID="$(aws ssm get-parameter --name /aws/service/eks/optimized-ami/${K8S_VERSION}/amazon-linux-2-gpu/recommended/image_id --query Parameter.Value --output text)"

Step 3: Create a Cluster

The following configs will create an EKS cluster with the user configured in aws-cli having the relevant permissions to create an EKS cluster.

curl -fsSL https://raw.githubusercontent.com/aws/karpenter-provider-aws/v"${KARPENTER_VERSION}"/website/content/en/preview/getting-started/getting-started-with-karpenter/cloudformation.yaml > "${TEMPOUT}" \
&& aws cloudformation deploy \
  --stack-name "Karpenter-${CLUSTER_NAME}" \
  --template-file "${TEMPOUT}" \
  --capabilities CAPABILITY_NAMED_IAM \
  --parameter-overrides "ClusterName=${CLUSTER_NAME}"

eksctl create cluster -f - <<EOF
---
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
  name: ${CLUSTER_NAME}
  region: ${AWS_DEFAULT_REGION}
  version: "${K8S_VERSION}"
  tags:
    karpenter.sh/discovery: ${CLUSTER_NAME}

iam:
  withOIDC: true
  podIdentityAssociations:
  - namespace: "${KARPENTER_NAMESPACE}"
    serviceAccountName: karpenter
    roleName: ${CLUSTER_NAME}-karpenter
    permissionPolicyARNs:
    - arn:${AWS_PARTITION}:iam::${AWS_ACCOUNT_ID}:policy/KarpenterControllerPolicy-${CLUSTER_NAME}

iamIdentityMappings:
- arn: "arn:${AWS_PARTITION}:iam::${AWS_ACCOUNT_ID}:role/KarpenterNodeRole-${CLUSTER_NAME}"
  username: system:node:{{EC2PrivateDNSName}}
  groups:
  - system:bootstrappers
  - system:nodes
  ## If you intend to run Windows workloads, the kube-proxy group should be specified.
  # For more information, see https://github.com/aws/karpenter/issues/5099.
  # - eks:kube-proxy-windows

managedNodeGroups:
- instanceType: m5.large
  amiFamily: AmazonLinux2
  name: ${CLUSTER_NAME}-ng
  desiredCapacity: 2
  minSize: 1
  maxSize: 10

addons:
- name: eks-pod-identity-agent
EOF

export CLUSTER_ENDPOINT="$(aws eks describe-cluster --name "${CLUSTER_NAME}" --query "cluster.endpoint" --output text)"
export KARPENTER_IAM_ROLE_ARN="arn:${AWS_PARTITION}:iam::${AWS_ACCOUNT_ID}:role/${CLUSTER_NAME}-karpenter"

echo "${CLUSTER_ENDPOINT} ${KARPENTER_IAM_ROLE_ARN}"

Unless your AWS account has already been onboarded to EC2 Spot, you will need to create the service-linked role to avoid the ServiceLinkedRoleCreationNotPermittederror.

aws iam create-service-linked-role --aws-service-name spot.amazonaws.com || true
# If the role has already been successfully created, you will see:
# An error occurred (InvalidInput) when calling the CreateServiceLinkedRole operation: Service role name AWSServiceRoleForEC2Spot has been taken in this account, please try a different suffix.

Step 4: Install Karpenter

# Logout of helm registry to perform an unauthenticated pull against the public ECR
helm registry logout public.ecr.aws

helm upgrade --install karpenter oci://public.ecr.aws/karpenter/karpenter --version "${KARPENTER_VERSION}" --namespace "${KARPENTER_NAMESPACE}" --create-namespace \
  --set "settings.clusterName=${CLUSTER_NAME}" \
  --set "settings.interruptionQueue=${CLUSTER_NAME}" \
  --set controller.resources.requests.cpu=1 \
  --set controller.resources.requests.memory=1Gi \
  --set controller.resources.limits.cpu=1 \
  --set controller.resources.limits.memory=1Gi \
  --wait

Once the installation is done, you can create NodePool and define the instance family, architecture, and start using Karpenter as your cluster autoscaler. For detailed installation information and its usage, feel free to refer to its documentation.

Use Cases

Karpenter is used to automatically provision and optimize Kubernetes cluster resources, ensuring efficient and cost-effective scaling. It dynamically adjusts node capacity based on workload demands, reducing over-provisioning and underutilization, thus enhancing performance and lowering cloud infrastructure costs. Check out this blog to understand in-depth about Karpenter and Cluster Autocaler.

3. Devtron

Devtron is a tool integration platform for Kubernetes and enables swift app containerization, seamless Kubernetes deployment, and peak performance optimization. It 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.

Installation

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

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

helm repo update devtron

helm install devtron devtron/devtron-operator \
--create-namespace --namespace devtroncd \
--set installer.modules={cicd}

Check out the complete guide here. If you have questions, please let us know on our discord channel.

Use Cases

Devtron simplifies Kubernetes adoption by addressing key challenges, making it easier to deploy, monitor, observe, and debug applications at scale.

Here's how Devtron helps:

1. Simplifying the Adoption Process:

Single Pane of Glass: Provides a unified view of all Kubernetes resources, enabling easy navigation and understanding of cluster components.
Real-Time Application Status Monitoring: Displays the health and status of applications in real time, highlighting potential issues and unhealthy components.
Simplified Debugging: Offers tools like event logs, pod logs, and interactive shells for debugging issues within the Kubernetes environment.
Containerization Made Easy: Provides templates and options for building container images, simplifying the containerization process for various frameworks and languages.

2. Streamlining Tool Integration:

Helm Marketplace: Integrates with the Helm chart repository to easily deploy and manage various Kubernetes tools.
Built-in Integrations: Offers native integrations with popular tools like Grafana, Trivy, and Clair for enhanced functionality.

3. Simplifying Multi-Cluster/Cloud Workloads:

Centralized Visibility: Provides a unified view of applications across multiple clusters and cloud environments, enabling consistent management.
Environment-Specific Configurations: Allows setting environment-specific configurations, making it easier to manage applications in diverse environments.

4. Simplifying DevSecOps:

Fine-Grained Access Control: Enables granular control over user permissions for Kubernetes resources, ensuring secure access.
Security Scanning and Policies: Offers built-in security scanning with Trivy and allows configuring policies to enforce security best practices.

4. K9s

K9s is a terminal-based UI to interact with your Kubernetes clusters. This project aims to make it easier to navigate, observe, and manage your deployed applications in the wild. K9s continually watch Kubernetes for changes and offer subsequent commands to interact with your observed resources.

Installation

K9s is available on Linux, macOS, and Windows platforms. You can get the latest binaries for different architectures and operating systems from the releases on GitHub.

MacOS/ Linux

 # Via Homebrew
 brew install derailed/k9s/k9s

Windows

# Via chocolatey
choco install k9s

For other ways of installation, feel free to check out the documentation of K9s.

Use Cases

K9s make it much easier as compared to other Kubernetes clients like kubectl to manage and orchestrate applications on Kubernetes. You get a terminal-based GUI which helps you manage your resources,

Resource Monitoring and Visibility : It provides continuous monitoring of your Kubernetes cluster, offering a clear view of resource statuses. It helps you understand your K8s cluster by displaying information about pods, deployments, services, nodes, and more. With K9s, you can easily navigate through cluster resources, ensuring better visibility and awareness.
Resource Interaction and Management : K9s allows you to interact with resources directly from the terminal. You can view, edit, and delete resources without switching to a separate management tool. Common operations include scaling deployments, restarting pods, and inspecting logs. You can also initiate port-forwarding to access services running within pods.
Namespace Management : This lets you focus on specific namespaces within your cluster. You can switch between namespaces seamlessly, making it easier to work with isolated environments. By filtering resources based on namespaces, you can avoid clutter and stay organized.
Advanced Features : It also offers advanced capabilities, such as opening a shell in a container directly from the UI. It supports context switching between different clusters, making it convenient for multi-cluster environments. Additionally, K9s integrate with vulnerability scanning tools, enhancing security practices.

5. Winter Soldier

Winter Soldier is an open-source tool from Devtron, it enables time-based scaling for Kubernetes workloads. The time-based scaling with Winter Soldier helps us to reduce the cloud cost, it can be deployed to execute things such as:

Batch deletion of the unused resources
Scaling of Kubernetes workloads

If you want to dive deeper into it, please check the following resources -

Installation steps - https://devtron.ai/blog/winter-soldier-scale-down-your-infrastructure-in-the-easiest-possible-way

Please star us on our Github: https://github.com/devtron-labs/winter-soldier

Use Cases

Winter Soldier is a valuable tool for anyone who wants to:

Optimize Cloud Costs: By automatically scaling Kubernetes workloads based on time, Winter Soldier helps reduce unnecessary resource usage, lowering cloud bills.
Automate Routine Tasks: Tasks like deleting unused resources or scaling workloads at specific times can be automated, freeing up time for other initiatives.
Improve Resource Utilization: By ensuring resources are only allocated when needed, Winter Soldier maximizes resource utilization and improves overall efficiency.
Implement Time-Based Scaling: It's ideal for scenarios where workloads have predictable usage patterns (e.g., a website that experiences heavy traffic during specific hours) or when resources need to be adjusted based on time.

Examples:

E-commerce Website: Scale up resources during peak shopping hours and scale down during off-peak periods to reduce costs.
Data Processing Jobs: Schedule resource scaling for batch processing jobs that run only during specific time windows.
Development and Testing Environments: Automatically scale down development and testing environments after hours to minimize resource usage.

Key Benefits:

Cost Reduction: Optimizing resource utilization translates to lower cloud bills.
Improved Efficiency: Automating resource management frees up time for other tasks.
Enhanced Reliability: By ensuring resources are allocated appropriately, Winter Soldier helps improve the reliability of Kubernetes applications.

6. Silver Surfer

Currently, there is no easy way to upgrade Kubernetes objects in case of Kubernetes upgrade. It's a tedious task to know whether the current ApiVersion of the Object is Removed, Deprecated, or Unchanged. It provides details of issues with the Kubernetes object in case they are migrated to a cluster with a newer Kubernetes version.

Installation

Just with a few commands, it's ready to serve your cluster.

git clone https://github.com/devtron-labs/silver-surfer.git
cd silver-surfer
go mod vendor
go mod download
make

It's done. A bin directory might have created with the binary ready to use ./kubedd command.

It categorises kubernetes objects based on change in ApiVersion. Categories are:

Removed ApiVersion
Deprecated ApiVersion
Newer ApiVersion
Unchanged ApiVersion

Within each category it identifies the migration path to the newer Api Version, possible paths are:

It cannot be migrated as there are no common ApiVersions between the source and target Kubernetes version
It can be migrated but has some issues which need to be resolved
It can be migrated with just an ApiVersion change

This activity is performed for both current and new ApiVersion.

Check out our Github repo and give it a star ⭐️: https://github.com/devtron-labs/silver-surfer

Use Cases

Pre-Upgrade Planning: Silver Surfer helps you identify potential issues before the upgrade, giving you time to plan and resolve them.
Streamlined Upgrade Process: The tool provides detailed guidance, minimizing downtime and errors during the upgrade.
Kubernetes Object Management: Silver Surfer provides greater visibility into the compatibility of your objects with different Kubernetes versions, aiding in managing your cluster.

Key Benefits

Reduced Upgrade Complexity: Simplifies the Kubernetes upgrade process, reducing stress and the potential for errors.
Improved Uptime: Minimizes downtime during the upgrade process.
Enhanced Cluster Management: Provides a better understanding of your Kubernetes objects and their compatibility with different versions.

7. Trivy

Trivy is a simple and comprehensive vulnerability scanner for containers and other artifacts. A software vulnerability is a glitch, flaw, or weakness present in the software or in an Operating System. Trivy detects vulnerabilities of OS packages (Alpine, RHEL, CentOS, etc.) and application dependencies (Bundler, Composer, npm, yarn, etc.). Trivy is easy to use. Just install the binary and you're ready to scan. All you need to do for scanning is to specify a target such as an image name of the container.

Installation

Installing from the the Aqua Chart Repository.

helm repo add aquasecurity https://aquasecurity.github.io/helm-charts/ 
helm repo update 
helm search repo trivy 
helm install my-trivy aquasecurity/trivy

Installing the Chart.

To install the chart with the release name my-release:

helm install my-release .

The command deploys Trivy on the Kubernetes cluster in the default configuration. The Parameters section lists the parameters that can be configured during installation.

Know more about Trivvy installation here.

Use Cases

DevSecOps Integration: Trivvy seamlessly integrates into your CI/CD pipelines, identifying vulnerabilities early in the development process and enabling automated remediation.
Secure Container Deployment: It ensures only secure container images are deployed to production by scanning them before deployment and integrating with container registries for continuous scanning.
Ongoing Security Monitoring: Enables regular vulnerability scans and provides detailed reports, allowing for proactive security maintenance and tracking of remediation efforts.
Beyond Containers: Extend security assessments to operating systems, server configurations, and other infrastructure components.
Software Supply Chain Analysis: Analyze your entire software supply chain, from source to deployment, to identify and address vulnerabilities at every stage.

8. Cert-Manager

Cert Manager is an open-source tool designed to automate the management and provisioning of digital certificates in Kubernetes environments. It solves the challenge of handling TLS/SSL certificates for applications running on Kubernetes by simplifying the process of obtaining, renewing, and distributing certificates. Cert Manager enhances security and reduces operational complexity, ensuring that applications have valid and up-to-date certificates for secure communication.

It automates the lifecycle of your TLS certificates! No more manual renewal!

Installation

You don't require any tweaking of the cert-manager install parameters.

The default static configuration can be installed as follows:

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.15.1/cert-manager.yaml

Checkout our blog to learn how to setup cert-manager using Devtron: https://devtron.ai/blog/kubernetes-ssl-certificate-automation-using-certmanager-part-1

Use Cases

Automated Certificate Acquisition & Renewal: Effortlessly obtain and renew certificates from providers like Let's Encrypt, eliminating manual effort and ensuring continuous security.
Secure Ingress Controllers: Automatically provision certificates for Ingress controllers, enabling secure HTTPS communication for services exposed through the Ingress.
Centralized Certificate Management: Manage all your certificates from a single point of control, simplifying issuance, renewal, and revocation.
Enhanced Application Security: Strengthen encryption and protect sensitive data by ensuring valid and up-to-date TLS/SSL certificates.
Streamlined Operations: Reduce operational overhead, minimize downtime, and ensure continuous application availability by automating certificate management.

9. Istio

Istio extends Kubernetes to establish a programmable, application-aware network. Working with both Kubernetes and traditional workloads, Istio brings standard, universal traffic management, telemetry, and security to complex deployments.

Check out the Istio docs for Getting Started and a complete walkthrough of Canary Deployment with Flagger and Istio on Devtron.

Use Cases

Simplify Microservice Communication :

Istio abstracts away complex networking concerns like service discovery, routing, and load balancing.
Developers can focus on business logic while Istio handles communication between microservices.

Enhance Security:

Implement consistent authentication, authorization, and encryption across all services using Istio.
It mitigates security risks by enforcing security policies throughout the mesh.

Traffic Management :

Istio enables A/B testing, canary deployments, and blue-green deployments.
You can control traffic routing, timeouts, and fault injection seamlessly.

Observability and Monitoring :

Monitor service behavior, track performance metrics, and troubleshoot issues with Istio.
It integrates with observability tools for better insights into your microservices.

10. KRR

Robusta KRR (Kubernetes Resource Recommender) is a CLI tool for optimizing resource allocation in Kubernetes clusters. It gathers pod usage data from Prometheus and recommends requests and limits for CPU and memory. This reduces costs and improves performance.

The installation is pretty straight-forward. You can install the binary directly from their releases. To install the CLI, depending upon your operating system, you can install the KRR cli and use it for optimizing the resources. You can use Brew for installing on mac:

brew tap robusta-dev/homebrew-krr

brew install krr

Use Cases

Cost Savings: Reduce cloud bills by recommending optimal resource requests, eliminating over-provisioning.
Performance Boost: Improve application responsiveness by preventing resource contention and ensuring sufficient resources.
Data-Driven Insights: Gain insights into resource usage patterns for better planning and scaling decisions.
Automated Optimization: Integrate with CI/CD pipelines to automatically adjust resource allocation for continuous optimization.

11. Kyverno

Kyverno is a Kubernetes-native policy engine designed for Kubernetes platform engineering teams. It enables security, automation, compliance, and governance using policy-as-code. Kyverno can validate, mutate, generate, and cleanup configurations using Kubernetes admission controls, background scans, and source code respository scans in real-time. Kyverno policies can be managed as Kubernetes resources and do not require learning a new language. Kyverno is designed to work nicely with tools you already use like kubectl, kustomize, and Git.

Installation

In order to install Kyverno with Helm, first add the Kyverno Helm repository.

helm repo add kyverno https://kyverno.github.io/kyverno/

Scan the new repository for charts.

helm repo update

Optionally, show all available chart versions for Kyverno.

helm search repo kyverno -l

Check the whole guide here.

And be sure to check out our blog on securing Kubernetes clusters with Kyverno policies.

Use Cases

Security: Enforce policies to prevent deployments with root privileges, restrict resource requests, control network access, and secure sensitive data.
Compliance: Implement auditing, labeling, and access control policies to meet regulatory requirements.
Best Practices: Automate resource validation, enforce naming conventions, and manage resource lifecycles.
Extend Kubernetes: Customize admission control and validate custom resources.

12. Opencost

OpenCost is a vendor-neutral open-source project for measuring and allocating cloud infrastructure and container costs. It’s built for Kubernetes cost monitoring to power real-time cost monitoring, showback, and chargeback. It is a sandbox project with the Cloud Native Computing Foundation (CNCF).

Check out the Installation guide to start monitoring and managing your spend in minutes. Additional documentation is available for configuring Prometheus and managing your OpenCost with Helm.

Use Cases

Identifying Costly Workloads: Identify specific pods or deployments consuming excessive resources and take steps to optimize their resource allocation.
Allocating Costs to Teams: Use OpenCost to generate detailed reports showing the cost incurred by each team or project using your Kubernetes cluster.
Right-sizing Resources: Optimize resource requests and limits for pods based on actual usage, reducing unnecessary resource allocation and saving costs.
Predictive Cost Management: Forecast future costs based on historical data and identify potential spikes in resource consumption to proactively adjust resource allocation or budget.

Conclusion

Kubernetes has revolutionized the way we build and deploy applications. However, its complexity can be daunting. The 12 tools we've explored provide a comprehensive toolkit for simplifying and optimizing your Kubernetes management.

The Coud-native landscape is overflowing with tools, each serving a specific purpose. Remember, there's no one-size-fits-all solution. Carefully evaluate your use case and choose the tools that best address your specific needs for a more efficient, secure, and cost-optimized Kubernetes experience.

By leveraging these powerful tools, you can unlock greater efficiency, reduce costs, enhance security, and ultimately, focus on delivering innovative applications faster. So, embrace these powerful tools and build a better infrastructure with confidence!

If you have any questions, or want to discuss any specific usecase, feel free to ask them in our Discord Community.

Happy Deploying!

Devtron Year in Review 2023

Akanksha Bhasin — Tue, 23 Jan 2024 09:25:57 +0000

2023 has been a phenomenal year for us. As we bid farewell to a remarkable year, it's time to pause, reflect, and celebrate the extraordinary journey. We soared to new heights, achieving milestones and making impactful strides in the world of Cloud-native DevOps solutions. Let’s take a deep dive into the key feature releases, global engagements, strategic partnerships, and community acknowledgments that have defined our transformative year.

💼 All Things Product

We channeled our efforts into expanding our product suite for DevOps and cloud-native development, focusing on fostering efficient workflows, encouraging collaboration, enhancing developer productivity and ensuring robust governance. We simplified the building and pushing capabilities across diverse platforms, introduced features that magnified team collaboration, provided tools for streamlined debugging and deployment, and braced our systems with robust governance mechanisms.

🌟 Here are the Key Features releases:

Resource Browser - Manage and monitor Kubernetes resources via web browser with our comprehensive dashboard. Say goodbye to endless kubectl commands.
Jobs - Optimize workflows by automating sets of repetitive tasks
CD Filter - Take charge of when and where deployments occur with our conditional deployment feature.
Scoped variable - Global variables that reduce the repetition of defining/updating variables & help make application configuration easier & secure.
Notifications - Elevate team collaboration with event-based notifications and approval alerts received directly on your preferred platforms.
Image Approval & Config Approval - Ensure deployment accuracy & safeguard your system configurations with this advanced governance feature

But those aren't the only features we've released! There’s much more in store for you. Don’t forget to check out our comprehensive product blog which includes all our detailed product enhancements that will help your team accelerate Kubernetes adoption.

🏄‍♂️ _ Dig into more detailed insights here: _ https://devtron.ai/blog/devtron-major-feature-updates-2023

🌍 Events & Conferences around the globe

KubeCon EU & North America: Representing Devtron at one of the largest conferences in the cloud-native world has been a beautiful experience for us. We had a great time exchanging knowledge, gathering insights from industry experts to fuel our development endeavors and immersing in global Kubernetes trends.
Diverse Engagements: Participation in multiple events like AWS Reinvent, Kubeday India & Singapore, AWS Summit, DevOps Days Conclave Awards, Insurtech, KCD Bangalore, Hacktoberfest Webinars, DevOps Days Bangalore, partner meetups, and more!

🤝 Strengthening Ties with AWS: A Milestone for Devtron

Celebrating one year of the ISV partnership with Amazon Web Services, we have marked numerous achievements within this period:

Our product passed verification in just one month, ensuring compliance and quality.
Our swift listing on the AWS marketplace resulted in acquiring our first user within two weeks, showcasing swift market adoption.
Applying for two competencies, #DevOps and #Graviton, we attained both acknowledgments within a remarkable two-month span after several iterations.

This significant milestone signifies our commitment to deepening our collaboration with AWS, marking an exciting phase in our partnership journey.

🚀 Our Phenomenal Product Hunt Launch

The astounding support we received during our Product Hunt launch was one of our year's high points. The engagement, feedback, and encouragement from the global tech community fueled our voyage to new heights, earning us a feature in the highly regarded Product Hunt newsletter.

🏆 Honoured at DevOps days Conclave Awards

With immense pride, we accepted accolades at the DevOps Days Conclave Awards as the “Most Innovative DevOps Vendor”.

💗 We love you 3000!

We reached 3.7k stars on GitHub! This honour is a testament to the trust and support that developers worldwide have shown us. 🌟

These enriching interactions are more than just memories; they have become the stepping stones shaping our strategic roadmap for 2024. 🚀

Devtron's Major Updates for 2023 - Reviewing the 18 Most Important Feature Releases

Akanksha Bhasin — Tue, 23 Jan 2024 07:25:00 +0000

At Devtron, we collaborate with our customers to define the future of the product and create the software they need to achieve their goals. From improved multi-platform support and enhanced collaboration features to dynamic management enhancements, and robust governance tools, 2023 marked a year of remarkable product growth and advancement. In this post, we discuss the major feature releases that occurred in 2023, the problems they solve, and the value they deliver.

1. Multi-platform and Multi-Cloud Support

Multi-platform remote build: Most companies run their software on multiple compute architectures. You might have a collection of ARM, AMD, and Intel CPUs in your environments. Running your software would require a new build for each architecture. Without Devtron, this is a time consuming process.
- Devtron's Solution: Our multi-platform remote build feature resulted in reducing build time from an hour (using older emulation methods) to six minutes for one of our application by enabling parallel build processes across different architectures using BuildX. That's a 90% decrease in build time!
Push images to multi cloud: We introduced a new Copy Container Image Plugin that empowers you to push your container images into multiple repositories, overcoming the previous limitations of single-repository use hence saving build time and costs. This caters to multi-cloud architecture, enabling repositories across various environments such as AWS, Azure, and GCP and for image promotions.

2. Collaboration Enhancements

Resource Catalog: Managing lots of microservices is tricky. There’s a lot of information to keep track of, like who is responsible for what, how to use the services, and who to talk to for certain approvals. Different companies keep track of this information in various ways. Some might use Google Docs, while others might use project management tools like Jira. This is important because when someone new joins the company, they need to get up to speed quickly on how everything works and what they need to know to manage these services effectively. Clear documentation and good communication are key to making sure everything runs smoothly.
- Devtron's Solution: The Resource Catalog acts like a knowledge base by providing one-stop visibility to all your resource information. You can create a catalog of any resource within Devtron, like applications, clusters, or jobs within an organization, to provide visibility over documentation, dependent microservices, impacting microservices or any relevant information that helps in better collaboration, debugging or knowledge transfer.
Granular Access to Resource Browser: Using kubectl commands to manage your Kubernetes clusters gets tiresome. Wouldn't it be great if there was a web browser-based GUI alternative that made it easier and faster to manage Kubernetes?
- Devtron's Solution: Well now there is - Devtron built Advanced Kubernetes resource management with fine grained role-based access control, providing an easy to use dashboard for managing and monitoring your Kubernetes clusters and their resources. Make Devtron the first thing you install to a fresh Kubernetes cluster and it will make your life much easier.
Notifications: We've streamlined our event-based notifications for better team collaboration and approval requests. Get timely updates about build statuses, deployment outcomes, and image or config approval requests, delivered straight to your preferred platform. Set up your webhook and receive notifications wherever you want - your internal IDP, task board, Discord, Pagerduty & beyond.

3. Debugging & Developer productivity

Ephemeral Container: When you run application in production you want to streamline the container as much as possible for better performance and security. This is great, but it causes an issue when problems arise with your production containers. It becomes impossible to debug the production environment without having the proper tools available in those containers.
- Devtron's Solution: Ephemeral containers are a special type of short-lived container added to an existing Pod for administrative actions like debugging scenarios where 'kubectl exec' can't help. They are specialized containers that contain the exact debugging utilities required to identify the root cause of production problems. Your developers or SREs can launch these specialized containers right from Devtron and avoid the painful and time consuming process of having to recreate the problem in a different environment.
Friendly deployment and debugging in Dev-QA environment: Spanning across 2023, Devtron launched a bunch of new features that facilitate friendly (easier) deployment and debugging in Dev and QA environments. To facilitate quick, frequent changes you can; toggle your CI sources, effortlessly sync a deployed microservices from any other environments(maybe for debugging or your dev setup needs that microservice), one click hibernation in off hours, eliminating the need for tedious deletion and recreation of pipelines. Essentially, Devtron can reduce setup time in Dev or QA from hours to just a few seconds.

4. Management Enhancement

CD Filter: Distributing software at large scale in customer environments presents several challenges for companies. These challenges are complex and multifaceted, impacting various aspects of the software deployment and maintenance process including compatibility and integration issues, security concerns, and version and configuration management issues.
- Devtron's Solution: Take control of your deployments with our CD filter feature, enabling conditional deployment based on Common Expression Language (CEL). Shape your release channels and establish criteria-based deployments with ease, all while ensuring your images tick the boxes for environment-specific deployment.
Scoped Variables: These are global variables that can be assigned different values at different scopes or stages of an application. You can define global as well as scope-specific values based on the cluster, environment, application, or a combination of application and environment. This feature reduces the repetition of defining or updating variables and makes data maintenance easier and more secure.
Review Configuration Changes: Enables pre-deployment evaluation of configuration changes, facilitating error prevention and deployment confidence by highlighting differences and conflicts before the actual deployment process
Application Groups: Streamlines the deployment of microservices by enabling you to build and deploy multiple applications simultaneously. It’s beneficial when your microservices are interdependent, as a change in one service often triggers the need to redeploy others.

5. Capability Enhancement

OCI Push & Pull: The OCI Push builds & packages an image with configurations into a Helm chart and pushes it to a registry. It also allows packaging and delivering Helm charts to isolated clusters where direct access is not feasible(Customer-End Deployment to Air-Gapped Environments).

OCI Pull retrieves these packaged charts from any chart registry for deployment, facilitating deployments in complex or restricted environments.
Jobs: Jobs provide a way to automate your repetitive tasks. You can write your custom scripts or configure preset plugins and execute them in environments of your choice. This helps in streamlining your task execution, enhancing control, simplifying configuration updates and makes execution easier with a concise run history.

6. Governance

Image Approval & Config Approval: Devtron's image approval and config approval features help maintain control and quality standards in deployment. This way, unauthorized or harmful alterations are prevented, enhancing your deployment's reliability.
- Image approval lets you set conditions for deployment - an image can only be deployed after it's approved by a designated person or group.
- Config approval safeguards your system configurations. Any changes to the configurations require approval for additional security.
User management through SSO groups: This feature leverages Single Sign-On (SSO) groups for user management, enhancing security and access control. It facilitates centralised user access control and enforces consistent access policies across various platforms and applications.For instance, the team can use platforms like Microsoft's Active Directory or LDAP to group users by roles. Additionally, for organisations with thousands of users, this feature eliminates the tedious task of manually adding and granting permissions to each user. Instead, it syncs directly with their active directory or SSO mechanism, automating the process of assigning user permissions.
Scanning with Trivy and security policies: DevSecOps isn't just a buzzword, it's an important process that helps ensure new software releases are free from known vulnerabilities when they are delivered to production. The problem with DevSecOps is that it adds extra work to the already full plate of activities that Developers are performing.
- Devtron's Solution: Instead of adding extra tools with different UIs for Developers to learn, Devtron seamlessly integrates vulnerability scanning by Trivy (and Clair) into your Devtron CI/CD pipelines and automates security checks throughout the deployment process. This makes it much easier for your Developers to comply with security policies and helps ensure a more secure application environment for your end users.
Secure ways to add clusters at Devtron: Devtron ensures heightened security while adding clusters by not relying solely on direct connections. It now enables the use of secure methods like proxy and SSH tunneling, catering to companies with stringent access policies.
Mandatory Plugin Policies: With the business clammoring for new features, Developers need to build and deliver new software as quickly as possible. The DevOps team needs to ensure that corporate security and governance standards are followed throughout the SDLC. These goals are often at odds with each other.

Devtron's Solution: Devtron makes it easy for DevOps teams to provide a Developer self-service environment where policies are enforced but developers are free to work within the guardrails that have been defined. These policies are set by super admins (typically DevOps), enforcing the usage of certain plugins (which control security and governance) in all pipelines across the organization. If not used, the pipeline trigger can be blocked, or a warning is issued accordingly. Your Developers are now free to work as fast as they need to, within the guardrails that are required by each company.

7. Plugins at Devtron

Devtron's plugins, acting as add-ons, integrate with various tools to enhance versatility. Serving as problem solvers, these plugins customize the CI pipeline, enabling new features and automating tasks. They facilitate seamless interactions with external systems and also help in delivering critical notifications during building, testing, and deploying stages. A few ready-to-use plugins include JIRA, SonarQube, Terraform, semgrep, Jenkins, GitHub, etc. These integrations allow early issue detection, comprehensive code testing, and keep pull requests up-to-date, making the CI/CD process simpler and more efficient.

Join Our Community

As we celebrate the strides we've made in cloud-native development and DevOps, the anticipation for what the new year holds is truly exhilarating. Your support means the world to us, and we invite you to be a part of our vibrant community on Discord.

If you appreciate our product, consider giving us a star on GitHub. Questions or just want to chat? Feel free to 'book a session' with us. Let's embark on this exciting journey together, pushing the boundaries of technology.

Thank you for being an integral part of our innovation story! 🚀

Conversation Intelligence Quest: Python CI Challenge

Akanksha Bhasin — Thu, 20 Jan 2022 18:22:29 +0000

Test Out Your Python Skills on Building Conversation Intelligence Functions

Hey fellow devs!

We are thrilled to announce a new Python CI coding challenge on Qualified.io. Put your Python skills to the test and win some cool prizes and bragging rights by building conversation intelligence functions. In case you are not familiar with what Conversation Intelligence (CI) is, it’s essentially AI that can understand natural human conversations, explicitly and contextually.

📜 The Challenge:

In this cool challenge, you will take on the identity of a “Python Agent’ and venture into the mystic land of Convotopia. Combining your Python skills and CI APIs (provided by Symbl.ai), you will build functions for extracting the undiscovered secrets (conversation insights) hidden deep within Convotopia. Prepare yourself to take on greater challenges as you venture deeper into Convotopia.

The challenge is divided into 5 Levels, with each passing level you gain super powers to unlock the next level and be a Python hero in Convotopia.⛳

Start the challenge here: bit.ly/SymblCIQuest-Q1

⏳ Time Commitment:

The challenge will take approximately 1 hour and 30 mins (or less) to complete all levels, depending on your level of expertise with Python and/or conversation intelligence APIs (provided by Symbl.ai).

Why should you commit 1.5 hours of your life? You can win some cool prizes completing the challenge (see section below for details).

Approx time for each level:

Level 1. Access to Convotopia Land - 20 mins
Level 2. Connect with the locals - 20 mins
Level 3. Are you connecting with the locals? - 20 mins
Level 4. Let the extraction begin - 30 mins
Level 5. What is the ‘Talk of the town’ in Convotopia? - 30 mins

👨🏻‍💻👩🏻‍💻 Who Can Participate:

Our Challenge is open to programmers (or not) from all across the globe. If you are interested in building Python functions and exploring AI functions, this is the challenge for you.

🏆 Prizes:

Complete the challenge and win some cool prizes:

$50 Amazon gift card - The first 4 participants to complete the challenge with 100% by 15th February.
$25 Amazon gift card - not among the first 4 to complete the challenge or didn’t score 100%? No worries, every week, between 15th February to 30th March we will randomly select a winner who completed 80% or more of the challenge to win.
Symbl.ai Developer Swag - first 50 participants who complete 80% of the challenge by March 30th.
Certificate of completion - All participants who successfully complete the challenge, will receive a certificate. (bragging rights to share on social).

🔥 How to participate?

Head over to the Challenge to register yourselves & get started - Link ✔️
Join our slack channel 🚩
Publish a social media post about your participation and experience, and tag @symbldotai and @symbldev .📢
Add the #BuildWithSymbl #SymblQuest hashtag to your posts and share it with the community. ✨
Fill in the Challenge completion swag form.🎁

🤗 Join our Symbl.ai Community!

Become a part of our Slack community and do follow us on Twitter, Linkedin, Youtube, Github, Facebook and Instagram! ❤️

📩 Contact us

If you have any questions, please don't hesitate to drop me an email at (akanksha.bhasin@symbl.ai)

Happy Hacking!
May the source be with you! ✊🏻

✍🏽 By Akanksha Bhasin
DevRel @symbl.ai

Symbl.ai's Developer Month💻

Akanksha Bhasin — Thu, 20 Jan 2022 18:21:42 +0000

             Welcome to Symbl.ai’s Developer Month 👩‍🔬 👨‍🔬

Woot, woot!✨
Symbl.ai has launched Developer Month!❤️

To celebrate the thriving Developer Community all across the Globe we have launched Symbl.ai’s Developer Month! Join us to celebrate creativity, innovation & collaboration among the devs in these amazing 2 months.👩‍💻👨‍💻

How you can participate?
It's super easy!!
Join our events and fun activities such as meme contest, happy hours, Twitter Giveaway and more!
Build with Symbl.ai APIs or showcase your projects and learnings. Feel free to tag us and use the #SymblDevMonth hashtag along your journey; we would love to amplify your work!📢

How to join our Community?🌻
Join our Symbl.ai community here.
🔗Slack Group: https://bit.ly/symbldotai-slack
🔗Twitter: @SymblDev and @symbldotai
🔗Github: https://github.com/symblai

👉 Signup on the platform: https://bit.ly/Symbl-signup

What’s Next?

⭐Upcoming events in July

...

🚩July 14: Meme Contest

A one week contest hosted on slack to unleash your creativity skills! You are free to use any meme generator to create cool memes related to programming and development. The results will be announced on July 21 and top 5 submissions will receive exclusive Symbl swag.

🚩July 15: Hackathon Ideation Session 3: Transform One Iteration

App: Extract Time-Series Analysis of Sentiments from Calls with Symbl.ai’s Python SDK, Pandas, & Matplotlib.

🚩July 25: Giveaway

A twitter giveaway will run on Symbl.ai's twitter handle and 3 lucky winners will be awarded a prize.
Lot of cool swags in your way! Stay tuned!!

🚩July 30: Happy Hours

Happy hours are community connect sessions hosted for fun and to initiate engagement in the community.
Get a chance to network with folks all around the globe and build lifelong connections! Cool suprises are also lined up for you.😍

. . .

⭐Highlights from June

🚩June 16: Giveaway -

A Giveaway was hosted on Twitter on 16th June. 5 Winners were rewarded with Symbl.ai’s tshirt and exclusive stickers.

Giveaway Link

🚩June 17: Symbl.ai 101 -

Getting started with Symbl.ai on Postman and common integration and use cases were discussed.

Link to the session

🚩June 22: Slack AMA -

We are really glad to launch Symbl.ai’s AMA series. We had with us our 1st Guest - Toshish Jawale, co-founder and CTO of Symbl.ai
The AMA was hosted on #general channel of slack on Conversation Intelligence 101.

Link to the AMA discussion

🚩June 24: Symbl.ai Visualize session -

The audience was taught the basics of Symbl.ai as well as a demo was demonstrated on websockets and Real-Time Sentiment Analysis with Emojis was also shown.😃😐😞

Link to the session

🚩June 25: Developer Spotlight Series -

We are really glad to announce the first ever Symbl.ai's Developer Spotlight Series.
We had our first guest with us - Team Tier 4 who recently won the Symbl.ai’s Track Prize in Hackon 2.0.

Link to the discussion

✍🏽 By Akanksha Bhasin
May the source be with you!

Feel free to reach out to me via Twitter or Linkedin! ❤️

Symbl.ai’s Hacktoberfest 2021: Thank you for participating!

Akanksha Bhasin — Tue, 23 Nov 2021 07:19:06 +0000

It was our pleasure participating in the Hacktoberfest for the first time and we were absolutely thrilled to see the participation from our fellow developers of Symbl.ai Community. 👩‍💻👨‍💻

It feels like we just announced Symbl.ai’s Hacktoberfest a while back, but it has officially come to a close.

⭐ Some Amazing Stats from our 3 repos that were a part of hacktoberfest:

Symbl Agora - 32 contributions (12 issues + 20 PRs)
Symbl Twilio - 20 contributions (15 issues + 5 PRs)
Symbl Docs - 15 contributions (6 issues + 9 PRs)

On behalf of me and my Symbl.ai team, we thank each and every one of you for your contributions in open source. Your involvement and enthusiasm blew us away, with participants ranging from school kids, professionals, community members to people completely new to our ecosystem.

🏆 We would also like to appreciate our Top Contributors during the Hacktoberfest.

🚩 Huge shout out to our Project Maintainers and stakeholders from Symbl.ai Team: Vishal, Shivam, Akanksha, Rishabh, Marcelo, Vaibhav, Janhavi and Pema.

⏳ We’re currently in the process of reviewing all submissions, and everyone who completed our Hacktoberfest challenge will receive a limited edition T-shirt, and stickers depending on the contribution level.

✅ Participants who meet all the requirements will receive an email in the coming week with a swag form and shipping instructions. We appreciate your patience – they’re coming soon!

🤔 Anything you’d like to see at Symbl.ai’s Hacktoberfest next year? Let me know via email (akanksha.bhasin@symbl.ai).

💻 Hacktoberfest is over, but you still can contribute to our repositories anytime. Read more about us on Symbl.ai Docs + Open Source repos.🚀

🌻 Join our Symbl.ai community here

🔗 Slack Group: https://bit.ly/symbldotai-slack
🔗 Twitter: @SymblDev and @symbldotai
🔗Akanksha Bhasin’s Twitter

Happy Hacking!

Cheers,
Akanksha