Setting Up Flux CD

Flux CD is a powerful tool that enables GitOps workflows in Kubernetes, automating the deployment of applications based on updates found in Git repositories. In this guide, we will walk through the step-by-step process to install and configure Flux CD on your Kubernetes cluster. Let’s dive right in!

Prerequisites

Before we begin, ensure that you have the following prerequisites in place:

A running Kubernetes cluster (version 1.16 or later).
kubectl command-line tool installed and configured to communicate with your cluster.
A GitHub repository (or any Git provider) where you’ll store your Kubernetes manifests.
Git installed on your local machine if you plan to clone the repository.

Step 1: Install Flux CD

Flux CD can be installed using the Flux CLI. Follow these steps to install the CLI:

Install the Flux CLI:

Depending on your operating system, use one of the following commands:

For macOS:
```
brew install fluxcd/tap/flux
```
For Linux:
```
curl -s https://fluxcd.io/install.sh | sudo bash
```
For Windows, check the Flux installation page.
Verify the installation:

After installation, verify that the Flux CLI is installed correctly by running:
```
flux version
```

Step 2: Bootstrap Flux CD

Next, we need to bootstrap Flux CD into our Kubernetes cluster. Bootstrapping will install Flux and set up necessary resources to monitor your Git repository.

Set up your Git repository:

Make sure your Git repository contains the Kubernetes manifests you want to deploy. If you don’t have one, you can create a new repository on GitHub or any Git provider.
Bootstrap Flux with your repository:

Use the following command to bootstrap Flux CD with your Git repository. Make sure to replace YOUR_GITHUB_USERNAME, YOUR_REPOSITORY_NAME, and YOUR_GITHUB_TOKEN with the appropriate values.
```
flux bootstrap github \
  --owner=YOUR_GITHUB_USERNAME \
  --repository=YOUR_REPOSITORY_NAME \
  --branch=main \
  --path=clusters/my-cluster \
  --token=YOUR_GITHUB_TOKEN
```
Here, clusters/my-cluster is the directory inside the repository where the Kubernetes manifests will be stored. Ensure that this directory structure is created in your Git repository.

The bootstrap command will automatically install necessary components in your cluster, including the flux-system namespace, and configure it to track your repository.
Check the flux-system namespace:

Once the bootstrap process is complete, confirm that Flux components are running:
```
kubectl get pods -n flux-system
```
You should see several pods related to Flux CD, such as source-controller, kustomize-controller, and helm-controller.

Step 3: Configure Your Git Repository

After bootstrapping Flux, you need to set up your Git repository with Kubernetes manifests.

Create a directory for your Kubernetes manifests:

In your local Git repository, create the directory specified during the bootstrap process:
```
mkdir -p clusters/my-cluster
```

Add your first Kubernetes manifest:

Here’s an example of a simple deployment manifest for a sample application called nginx-sample.yml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Commit and push your changes:

Now that you have your manifest ready, commit and push the file to your Git repository:
```
git add clusters/my-cluster/nginx-sample.yml
git commit -m "Add nginx deployment manifest"
git push origin main
```

Step 4: Monitor Your Deployments

Flux CD continuously monitors the Git repository you provided during bootstrap. When it detects changes to the Kubernetes manifests in clusters/my-cluster, it will automatically apply those changes to your Kubernetes cluster.

You can check the status of your deployed resources using:

kubectl get deployments
kubectl get pods

You can also check the logs of the Flux pods for any synchronization issues:

kubectl logs -n flux-system -l app=source-controller

Step 5: Managing Updates

With Flux CD, any updates to the Git repository will be automatically reflected in your Kubernetes cluster. For example, you can update the nginx-sample.yml manifest to change the image version or the number of replicas.

Update your deployment manifest:

Change the image tag from nginx:latest to nginx:1.19, for instance. After modifying, your nginx-sample.yml should look like this:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: default
spec:
  replicas: 3  # Changed the number of replicas
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.19  # Changed the image version
        ports:
        - containerPort: 80

Commit and push the changes:

git add clusters/my-cluster/nginx-sample.yml
git commit -m "Update nginx deployment to version 1.19"
git push origin main

Verify the update:

Flux will detect the change and apply it automatically. Check the status of your deployment:
```
kubectl get deployment nginx -o wide
```

Conclusion

Setting up Flux CD in your Kubernetes cluster opens up a realm of possibilities for automating and managing your deployments using GitOps principles. By keeping your application definitions in Git, you can ensure version control, history, and a streamlined deployment pipeline.

Remember that this guide covered the basics of installing and configuring Flux CD, as well as managing updates to your deployments. Explore further by integrating Helm releases, configuring notifications, and scaling your applications with more complex Kubernetes manifests. The world of GitOps awaits, so get started with Flux CD today!

DevOps - Flux CD