Getting caught in the tangle of Kubernetes management is a familiar struggle, where orchestrating deployments becomes a web of complexities. If the need for a solution to streamline your Kubernetes workflows resonates with you, say hello to ‘GitOps.’
In this tutorial, you’ll unveil a powerful antidote to the common deployment headaches. Let GitOps emerge as the strategic solution to untangle your Kubernetes intricacies.
Confidence, control, and a newfound mastery over your infrastructure await!
Before immersing yourself in this tutorial, ensure you’ve got the following prerequisites to follow along seamlessly:
- Docker daemon running.
- Kubernetes Command-Line (kubectl) installed.
- Kubernetes Cluster with kind already running.
- A GitHub personal access token with repo and user permissions.
Exploring the Essence of GitOps
As a developer, you’re most likely familiar with version control systems (VCS) like Git, which you use to keep track of changes in your code. Now, GitOps is a process centered around using Git as the backbone for managing infrastructure and deploying applications.
Instead of manually setting up and managing your infrastructure components, GitOps uses configuration files stored in Git repositories. This approach is particular but not restricted to Kubernetes-based environments.
These benefits include enabling your team to improve version control, traceability, and collaboration in your development and operations workflows. But mind you, your team may encounter some drawbacks, like compatibility issues and a complex setup.
GitOps falls under the DevOps umbrella but differs in tool usage. How? GitOps commonly utilizes tools like Kubernetes, specific Git-driven CI/CD pipelines, and Infrastructure as Code (IaC) tools.
In contrast, DevOps encompasses a broader range of tools and practices, including GitOps, without being tied to a specific tool like Git.
Verifying a Kubernetes Cluster for Setting Up a GitOps Scenario
Coming straight from exploring the essence of GitOps, you’ll now set the stage for a robust GitOps implementation — verifying a Kubernetes cluster.
Setting up a GitOps scenario involves implementing a workflow and tooling for infrastructure and application deployment management.
To verify a Kubernetes cluster, follow these steps:
1. Open a terminal, execute the following
kind command to get all available Kubernetes clusters, and confirm you have an active one.
kind get clusters
In this tutorial, one cluster called sample-kind runs, as shown below.
The cluster’s configuration establishes a connection between the local environment and the Kubernetes cluster.
# Define a Kubernetes cluster using kind
# Specify the Kubernetes API version for kind
# Name of the cluster
# Single node with the role of a control plane
- role: control-plane
- | # Kubernetes administrative configurations applied during initialization
# Set a custom label for the node indicating it is ready for ingress
# Map container port 80 to host port 80 with TCP protocol
- containerPort: 80
# Map container port 443 to host port 443 with TCP protocol
- containerPort: 443
kubectl get nodes
As shown below, the output displays information about individual nodes that make up your Kubernetes cluster.
3. Lastly, run the below command to
get all running
services to ensure your service is deployed on your Kubernetes cluster.
kubectl get services
As in the output below, you’ll see the list of your services.
Installing the Flux CLI and Granting Flux Permissions
After confirming your Kubernetes cluster runs, you can set up your GitOps Scenario. This process involves installing a GitOps tool and granting permissions to access your private Git repositories.
This tutorial’s choice for a GitOps tool is Flux CD or Flux, an open-source continuous delivery tool. This tool monitors your Git repositories for changes in your Kubernetes manifests and automatically syncs the state you declared to the desired state in your Kubernetes cluster.
Before interacting with Flux, you must install the Flux CLI, which provides commands and functionalities.
💡 Note: This tutorial uses Flux because it has a large community and simpler setup and documentation than other tools.
To install Flux CLI and grant Flux permissions, carry out the following:
1. Run the
brew command below to
install Flux CLI on your system.
brew install fluxcd/tap/flux
💡 Explore the official documentation for instructions on installing the Flux CLI if you’re on a system other than macOS. The Flux CLI is also conveniently offered as a binary executable that is compatible with all major platforms (visit the GitHub releases page).
2. Once installed, execute the following commands to
export your GitHub username and personal access token.
These commands have no output but grant Flux access to your private Git repositories. Thus, replace the
<personal access token> and
<username> placeholders accordingly.
These exports allow Flux to consistently observe your Git repositories for modifications and autonomously initiate updates in response to code changes. This functionality guarantees that your Kubernetes cluster aligns with the desired state defined in your Git repository.
export GITHUB_TOKEN=<personal access token>
3. Now, run the following
flux command to
check your Kubernetes cluster is suitable for Flux.
This command checks for compatibility, detects issues, and verifies tools and permissions.
flux check --pre
If the checks pass, you’ll see an output similar to the one below.
Bootstrapping Flux in the Kubernetes Cluster
With Flux installed and your cluster validated, you must ensure Flux is seamlessly integrated into your Kubernetes environment. You’ll bootstrap Flux in your Kubernetes cluster and connect it to your Git repository for a smoothly operating Kubernetes environment.
To bootstrap Flux in your Kubernetes cluster, perform the following:
1. Execute the
flux bootstrap command below to perform the following and install Flux on your Kubernetes cluster:
bootstrap github– Indicate the bootstrap process is initiated with GitHub as the source for configuration and deployment.
--owner– Specify the owner of the GitHub repository, which you exported to the
--repository– Define the name of your existing GitHub repository (in this case,
--branch– Specify the branch to use within your GitHub repository for the Flux configuration (i.e.,
--path– Denote the path within your GitHub repository where the Flux configuration files are located (i.e.,
--personal– Suggest using personal access credentials for authentication with the GitHub repository.
flux bootstrap github \
Before you dive deeper, look at the following illustration to understand the typical GitOps workflow.
When you make changes via pull requests to your Git repository, like updating Kubernetes cluster configuration, the pipeline triggers a GitOps tool. That tool (i.e., Flux, Argo CD, Jenkins X, and so on) can be used to implement the GitOps workflow.
2. Once bootstrapping is complete, visit your GitHub repository to verify your configuration files, as shown below.
3. Next, run the following
k9s command to check the flux-system has been installed on your Kubernetes cluster.
k9s is a command-line interface (CLI) tool that provides a terminal-based graphical user interface (TUI) for interacting with Kubernetes clusters. This tool offers a more user-friendly and intuitive way to navigate and manage Kubernetes resources than raw
4. Now, type
:ns to enter the command mode and view the list of installed namespaces, select the flux-system namespace, and hit Enter. Doing so lets you switch to the flux-system namespace, switching the
k9s context to operate within that specific namespace.
In the output below, you’ll see some controller pods installed automatically during the Flux bootstrap process. By viewing the controller pods, you can confirm the components and controllers required for Flux are running.
Congratulations! You’re now using the
k9s tool to inspect the state of your Kubernetes cluster.
In this insightful journey of getting started with GitOps, you’ve embarked on a transformative exploration of orchestrating Kubernetes environments with Git at the helm. From understanding the fundamental principles of GitOps to setting up a practical scenario, you’ve learned the ropes and taken concrete steps toward a more efficient and streamlined workflow.
After diving into bootstrapping Flux in your Kubernetes cluster, you’ve unlocked the ability to manage your IaC seamlessly. This triumph marks the beginning of a more controlled and collaborative era.
Equipped with this newfound knowledge, why not extend your expertise by exploring advanced GitOps tools like Argo CD? Or fine-tune your CI/CD pipeline integration and dive deeper into Kubernetes orchestration?
The journey doesn’t end here; it evolves with every commit, deployment, and improvement!