Presenters

Source

GitOps Push: Simplifying Argo CD with Three Core Principles 🚀

Hey tech enthusiasts! 👋 We’re wrapping up a fantastic day, and I’m here to dive into a topic that’s been a game-changer for many of us: abstracting away the complexity of Argo CD. Our speaker, Andre Marcelo Tanner, a Member of Technical Staff at Cohere, shared some brilliant insights on how to make GitOps work even more seamlessly within your organization.

Cohere, an AI enterprise company that deploys cutting-edge AI models to solve real-world business problems, knows a thing or two about complex deployments. And Andre’s talk focused on a powerful concept: GitOps Push, a GitHub Action he developed, built upon three key principles that can truly elevate your Argo CD implementation.

What Exactly is GitOps? 🤔

At its heart, GitOps is simple: Git is your source of truth. This means your Git repository dictates your deployment pipelines, your infrastructure, and pretty much everything you’re doing, especially when working with tools like Argo CD.

While the concept is straightforward, the technical implementation can vary wildly. We’ve all been there, right? Looking at what others do, attending talks, and piecing together our own patterns. Some of us might be using AppSets, custom management plugins, hydrated manifests, or the classic “app of apps” pattern. The way we deploy Argo CD manifests themselves can also differ – some might even use Terraform, though Andre noted not many hands went up for that!

The goal? To make GitOps as simple as a git push. Push your code, and it deploys. This is the essence of what Andre calls “GitOps Push.”

The Three Pillars of Simpler GitOps 🛠️

Andre’s approach to simplifying Argo CD revolves around three powerful principles:

1. Abstract Away Your Deployment Process 🪄

When you first introduce Argo CD and GitOps, it’s easy to overwhelm your users with the intricacies of AppSets, Argo CD Apps, Kubernetes concepts, and more. The first principle is to hide this complexity.

• What it means: Developers don’t need to be Argo CD experts. You can provide them with a streamlined interface, like a GitHub Action, where they only need to define essential details.
• How it works: With GitOps Push, developers can focus on defining their GitOps repository and the necessary tokens. They can even customize application names and manifest sources if needed, but for standardized setups, the action can automatically locate and manage these.
• The Benefit: This abstraction simplifies the developer experience significantly. It also helps standardize your entire GitOps repository structure and directory layout, making it easier for everyone to understand and navigate. Imagine a clean structure where Argo CD Apps are organized by environment, and application manifests are neatly separated by application and environment.

This principle leads to a much more developer-friendly workflow. As Andre highlighted, leveraging existing Git tooling that developers already know and trust is a huge win!

2. Isolate Your Environments 🛡️

A common pitfall in GitOps is the tendency to mix deployment concerns, leading to unintended consequences. Andre’s second principle is to strictly isolate your environments.

• What it means: Treat your Argo CD manifests (the definitions of your applications) and your actual application manifests as separate, distinct entities. Deploy them independently for each environment.
• How it works: Instead of having a single deployment artifact that you push to multiple environments, create separate configurations for each. For instance, an “echoservice” might have its Argo CD app definition in a dev directory, with its own set of manifests. Then, separate directories for staging and production can house their respective manifests, even allowing for different tools like Kustomize per environment.
• The Benefit: This isolation drastically reduces the “blast radius” of any single change. If you need to update a template or an “app of apps” configuration, it won’t inadvertently affect all your environments. This clean separation is fundamental to the GitOps philosophy – everything is just files in a Git repo, and you can manage them with precision.

3. Harness the Power of Your Git Tooling 🧰

This principle is about leveraging what developers already know and use. As the previous talk emphasized, using familiar Git tooling is key.

• What it means: Don’t reinvent the wheel for deployment triggers, approvals, or rollbacks. Use the power of your existing Git platform.
• How it works:
  • Manual Deployments: Tools like GitHub Actions allow for workflow_dispatch, enabling manual triggers for deployments, just like a manual Git push.
  • Rollbacks: Need to undo a deployment? Simply use git revert. It’s that straightforward.
  • Approvals: Platforms like GitHub offer built-in approval workflows. You can use these existing mechanisms for deployment approvals, eliminating the need to build custom systems.
• The Core Idea: In GitOps, your Git repo is the source of truth. A deployment happens when you push to that Git repo, not when Argo CD pulls the files. This shifts control to your Git repository. You can define who or what has access to push to specific GitOps repositories, allowing for fine-grained control over production vs. development environments. You might even use separate Git repos for production-only manifests versus development manifests, each with its own access controls.

The Ultimate Goal: Developer Simplicity ✨

When you truly embrace these three principles, your developers can interact with your deployment system using the commands and workflows they’re already comfortable with. They’re just using Git! This is the mark of a successful GitOps implementation – it feels natural, intuitive, and requires minimal specialized knowledge beyond their core development skills.

Andre’s “GitOps Push” GitHub Action is a fantastic example of how to put these principles into practice, making Argo CD more accessible and powerful for everyone in your organization.

Thank you, Andre, for sharing these invaluable insights! 🙏

Appendix