Learn GitOps with ArgoCD - Pre-Requisite Skills & Environment Setup

#Introduction

Welcome to the Learn GitOps with ArgoCD series! In this series we'll build a modern deployment foundation from scratch: starting from understanding why GitOps exists, all the way to operating ArgoCD to manage applications in Kubernetes at a production level.

But before touching ArgoCD, there's one non-negotiable rule: GitOps sits at the intersection of many disciplines — Git, Kubernetes, YAML, containers, and CI/CD. If any one of those foundations is shaky, everything that follows will feel like building a house on sand. That's why episode 0 is dedicated to preparing the entire foundation: the skills you must have, the tools you need to install, hardware specifications, and verification steps so everything is ready as the series continues.

#Skills You Must Have

ArgoCD is essentially a Kubernetes operator that reads Git and materializes its contents into the cluster. So the skills below aren't just "nice to have" — they're "mandatory," because they'll be used in almost every episode.

#Git (branch, merge, pull request)

GitOps means "all changes through Git." You should be comfortable with git clone, git add, git commit, git push, git pull, and git checkout. Don't stop there — also understand the concepts of branch and pull request, because in production, environment changes are never pushed directly to the main branch. PRs are the gate for review and audit.

#Kubernetes Fundamentals

ArgoCD materializes manifests into the cluster, so you need to understand Kubernetes core objects: Pod, Deployment, Service, ConfigMap, Secret, Ingress, and Namespace. Most importantly, understand the concepts of desired state and reconciliation: Kubernetes continuously aligns the actual state with the declared one — exactly the same concept ArgoCD applies.

#YAML and Kubernetes Manifests

Most of the GitOps work is writing and reading YAML. Make sure you understand indentation rules (spaces, not tabs), the key: value structure, lists, and how to read multi-document manifests (---). Don't worry about aesthetics — what matters is consistency and validity.

#CI/CD Concepts

GitOps is part of CD (Continuous Delivery). You need to know the difference between CI (building and testing artifacts) and CD (delivering artifacts to environments). ArgoCD replaces the traditional "deploy stage," not the entire CI pipeline.

#Containers and Docker

ArgoCD doesn't run containers, but the applications it manages are container images. Understand the basics of Dockerfile, how to build and pull images, and the terms registry and tag. Without this, image configuration in manifests will feel like a puzzle.

#CLI Skills: kubectl and Git

All demos in this series use the CLI. At minimum you should be comfortable navigating the terminal and reading command output. kubectl is your bridge to the cluster; every command ArgoCD performs can also be verified manually with kubectl.

#Declarative vs Imperative

Understand the fundamental difference between declarative (describing the desired end result) and imperative (writing out the steps to reach the result). GitOps is built entirely on the declarative paradigm. If this concept is still fuzzy, episode 1 will revisit it from its historical roots.

#Networking Basics

ArgoCD communicates with the cluster and Git repositories over the network. Get familiar with port, DNS, HTTPS, and SSH. That's enough to understand why ArgoCD needs access to a Git repository (HTTPS token or SSH key) and to the cluster API server.

#Software and Tools to Prepare

As for the local cluster choice, my recommendation: use kind or minikube because they're the lightest for a lab, and k3s if you want an experience closer to production. All of them are valid — pick whichever is most comfortable for your OS.

#Minimum Hardware

GitOps isn't heavy work for your laptop, but a local Kubernetes cluster is quite resource-hungry. Recommendations:

#Verifying Your Setup

After installing all the tools, verify each one with a single command per tool. Make sure there are no errors before moving on to the next episode.

kubectl version --client
kubectl cluster-info
kubectl get nodes

helm version --short
kustomize version
argocd version --client

If you don't have a cluster yet, create one first:

kind create cluster --name gitops-lab
kubectl config current-context
kubectl get nodes

#Closing

Episode 0 is the gateway to this series. Here's what you must take with you:

• Understand the core skills: Git, Kubernetes fundamentals, YAML, CI/CD, Docker, and CLI.
• Prepare a local cluster plus kubectl, Helm, Kustomize, and the ArgoCD CLI.
• Make sure your hardware meets the minimum specs and your internet is stable.
• Verify all tools with the commands above before continuing.

In the next episode we dive into the most important part conceptually: the history of application deployment, the birth of GitOps by Weaveworks, the problems it solves, and why the pull model changes how we deploy. Make sure all tools are installed, because the hands-on material is about to begin!