Learning GitOps - FluxCD - Pre-Requisites Skill & Setup Environment

#Introduction

Welcome to the Learn GitOps - Continuous Delivery with FluxCD series! In this series we will build a modern deployment foundation from scratch: from understanding why GitOps was born, to dissecting the FluxCD architecture as one of the most mature GitOps implementations in the Cloud Native ecosystem, to operating FluxCD to synchronize Kubernetes with a Git repository automatically.

But before touching FluxCD, there is 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, the later material will feel like building a house on sand. That is why episode 0 is dedicated entirely to preparing the 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

FluxCD is essentially a collection of Kubernetes controllers that read Git and materialize its contents into the cluster. So the skills below are not merely "nice to have" — they are "must haves" because they will be used in nearly every episode.

#Git (branch, tag, commit, pull request)

GitOps means "all changes go through Git". You need to 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, tag, and pull request, because in production environment changes are never pushed directly to the main branch. PRs are the review and audit gate.

#Kubernetes Fundamentals

FluxCD materializes manifests into the cluster, so you must understand the core Kubernetes objects: Pod, Deployment, Service, ConfigMap, Secret, Ingress, and Namespace. Most importantly, understand the concepts of desired state and reconciliation: Kubernetes continuously aligns actual state with the declared one — the exact same concept FluxCD implements. Because FluxCD works through CustomResourceDefinition (CRD), you will also interact with custom objects often, so get to know how CRDs and controllers work.

#YAML and Kubernetes Manifests

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

#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). FluxCD replaces the traditional "deploy stage", not the entire CI pipeline.

#Containers and Docker

FluxCD does not run containers, but the applications it manages come in the form of container images. Understand the basics of Dockerfile, how to build and pull images, and the terms registry and tag. Without this, configuring images in manifests will feel like a puzzle.

#CLI Skills: kubectl, git, and flux

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 action FluxCD performs can also be verified manually with kubectl. The flux CLI is introduced in this episode and covered thoroughly in episode 5.

#Declarative vs Imperative

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

#Controller and Operator Concepts

FluxCD is built on the controller pattern: a loop that continuously compares actual state against desired state, then takes action to eliminate the difference. Get familiar with the terms reconcile, reconciliation loop, and Kubernetes operator. This concept is what lets FluxCD work continuously without human intervention.

#Software and Tools to Prepare

For local cluster choices specifically, my recommendation: use kind or minikube because they are the lightest for a lab, and k3s if you want an experience closer to production. All are valid — pick whichever is most comfortable with your OS.

#Minimum Hardware

GitOps is not heavy work for your laptop, but a local Kubernetes cluster can be quite resource-hungry. My recommendation:

#Verifying Your Setup

After installing all the tools, verify each one with a single command. 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
flux version

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

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

#Closing

Episode 0 is the gateway into this series. Here is what you must bring with you:

• Core skills: Git, Kubernetes fundamentals, YAML, CI/CD, Docker, CLI, and the controller concept.
• Tools installed: a local cluster plus kubectl, Helm, Kustomize, and the Flux CLI.
• Credentials ready: a GitHub/GitLab/Bitbucket account plus a Personal Access Token.
• Adequate hardware: RAM, storage, CPU, and a stable internet connection.
• Setup verified: all the verification commands above run without errors.

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