Deploy ArgoCD into Minikube

Automate deployments so they react to changes automatically (through gitops). Scaling should be done automatically as well as updating a version. Move from helm to ArgoCD for this. Just deploy ArgoCD with helm as part of the admin-charts

configs-homelab/components/minikube/argocd-config -> the ArgoCD config itselt
configs-homelab/components/minikube/manifests -> The deployment manifests which Argo watches (helm charts)
[ ] Deploy some dem apps (Apache, Nginx, Spring Pet Clinic, ...)
[ ] Forward the port range used by minikube in Vagrant (https://serverfault.com/questions/519429/vagrant-forward-a-range-of-ports)
- [ ] Document the used port range

Chat GPT:

To set up a playground for ArgoCD with Minikube and keep the ArgoCD configuration in a repository containing Helm scripts and the ArgoCD config, here's how I would start:

1. Prepare the Minikube Environment

Install Minikube, kubectl, and Helm on your local machine.

Start Minikube:

 minikube start --driver=your-preferred-driver

Set the Kubernetes context to Minikube:
```
 kubectl config use-context minikube
```

2. Create a Git Repository for ArgoCD Configurations

Create a new Git repository (e.g., argocd-playground).
This repository will contain:
- Helm scripts: For deploying ArgoCD itself.
- ArgoCD Application Manifests: To manage deployments within your Minikube environment.
- Configuration Files: For the specific setup of ArgoCD, such as projects, applications, repositories, and clusters.

3. Install ArgoCD using Helm

Add the ArgoCD Helm repo:

 helm repo add argo https://argoproj.github.io/argo-helm
 helm repo update

Create a helm/ folder in your repo and a values.yaml file for ArgoCD custom configuration:

 # helm/argocd/values.yaml
 server:
   service:
     type: NodePort  # Or LoadBalancer if using cloud or external access
   ingress:
     enabled: true  # If you want to expose ArgoCD via ingress
     hosts:
       - argocd.local

Install ArgoCD via Helm:

 helm install argocd argo/argo-cd -f helm/argocd/values.yaml -n argocd --create-namespace

4. Setup ArgoCD Configuration in the Repository

Inside the repository, create an argocd/ folder to contain ArgoCD configuration manifests.

Example structure:

 argocd-playground/
 ├── helm/
 │   └── argocd/
 │       └── values.yaml
 ├── argocd/
 │   ├── projects/
 │   ├── apps/
 │   ├── repositories/
 │   └── clusters/
 └── README.adoc

Define an ArgoCD project, for example, argocd/projects/sample-project.yaml:

 apiVersion: argoproj.io/v1alpha1
 kind: AppProject
 metadata:
   name: sample-project
   namespace: argocd
 spec:
   description: "Sample ArgoCD project"
   sourceRepos:
     - '*'
   destinations:
     - namespace: '*'
       server: '*'

Add ArgoCD applications under argocd/apps/.

5. Bootstrap ArgoCD with GitOps

In ArgoCD, configure the repo where your configurations live:

 argocd repo add https://github.com/yourusername/argocd-playground --username <user> --password <password>

You can either create your applications manually via the ArgoCD UI or use argocd CLI to sync them:

 argocd app create sample-app --repo https://github.com/yourusername/argocd-playground --path argocd/apps/sample-app --dest-namespace default --dest-server https://kubernetes.default.svc

6. Automating ArgoCD Sync

Set up automation for ArgoCD to sync automatically with your repository changes by enabling the auto-sync feature:
```
 spec:
   syncPolicy:
     automated:
       prune: true
       selfHeal: true
```

7. Testing and Iterating

Once ArgoCD is installed, log in to the ArgoCD web UI (port-forward it if necessary):
```
 kubectl port-forward svc/argocd-server -n argocd 8080:443
```

Username: admin, password: the initial password can be retrieved with:

 kubectl get secret argocd-initial-admin-secret -n argocd -o jsonpath="{.data.password}" | base64 -d

Now you can start experimenting with ArgoCD in your Minikube environment, managing deployments using the configuration stored in your Git repository.

To deploy a demo app like httpd:latest in your Minikube cluster using ArgoCD, you need to follow these steps:

1. Install ArgoCD on Minikube

First, ensure that ArgoCD is installed and running in your Minikube cluster.

kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Wait for ArgoCD to start:

kubectl get pods -n argocd

2. Expose ArgoCD API Server

To access the ArgoCD UI, you need to expose the ArgoCD API server on Minikube.

kubectl port-forward svc/argocd-server -n argocd 8080:443

Access the ArgoCD UI at https://localhost:8080 and login with the default username admin. You can retrieve the initial password with:

kubectl get secret argocd-initial-admin-secret -n argocd -o jsonpath="{.data.password}" | base64 -d

3. Create a Git Repository for the App's Helm/Manifests

Repository Structure: Store your Kubernetes manifests or Helm chart for the httpd deployment in a Git repository that ArgoCD will monitor. Here’s an example for a plain Kubernetes manifest setup:

# httpd-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpd-deployment
  labels:
    app: httpd
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpd
  template:
    metadata:
      labels:
        app: httpd
    spec:
      containers:
      - name: httpd
        image: httpd:latest
        ports:
        - containerPort: 80

# httpd-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: httpd-service
spec:
  selector:
    app: httpd
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Push the files to a Git repository, such as GitHub or GitLab.

4. Create an ArgoCD Application

In the ArgoCD UI or using a CLI, create an ArgoCD Application that will monitor the Git repository containing your app manifests or Helm chart. Here's an example of creating it via a YAML file:

# argocd-app.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: httpd-app
  namespace: argocd
spec:
  destination:
    namespace: default
    server: https://kubernetes.default.svc
  source:
    repoURL: 'https://github.com/your-repo/httpd-demo'
    path: 'manifests'
    targetRevision: HEAD
  project: default
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

Apply this file to your ArgoCD namespace:

kubectl apply -f argocd-app.yaml -n argocd

5. Sync the Application in ArgoCD

In the ArgoCD UI, locate the httpd-app and sync it to deploy the httpd app to your Minikube cluster. You should see the application in the UI.

Alternatively, you can sync via CLI:

argocd app sync httpd-app

6. Access the Deployed App

To access the deployed httpd service, you need to expose it. You can either use port-forwarding or Minikube’s service URL:

minikube service httpd-service

This command will open the service in your default web browser.

Summary

ArgoCD Setup: Installed ArgoCD in Minikube, set up a Git repository with deployment manifests.
Application Deployment: Created an ArgoCD Application to monitor the repository.
Sync & Access: Synced the application in ArgoCD and accessed the deployed app via Minikube's service command.

This setup uses plain Kubernetes manifests, but you can also use Helm charts for more complex applications. Would you prefer a Helm-based setup instead?

ArgoCD Autopilot is an exciting tool that can significantly enhance your experience with ArgoCD, especially in managing and deploying Kubernetes applications. Here are some key aspects and benefits of using ArgoCD Autopilot:

1. Simplified Application Management

Automation of GitOps Processes: Autopilot streamlines the GitOps workflow by automatically generating the necessary configurations and application manifests based on best practices.
Easy Setup: It helps set up ArgoCD applications quickly without the need for extensive manual configuration.

2. Opinionated Structure

Project Organization: Autopilot enforces a standard directory structure for your Git repositories, making it easier to manage and navigate applications.
Consistency: By providing a consistent structure, it helps teams adhere to best practices and reduce onboarding time for new developers.

3. Automatic Dependency Management

Helm Chart Management: Autopilot can manage Helm charts and their dependencies automatically, simplifying the deployment of complex applications.

4. Integration with GitHub

GitHub Actions Support: It integrates well with GitHub Actions for CI/CD workflows, allowing for seamless deployment pipelines.

5. Enhanced Monitoring and Health Checks

Built-in Monitoring: Autopilot includes features for health checks and monitoring of applications, ensuring that you can quickly identify and resolve issues.

6. Rollbacks and History Management

Automatic Rollbacks: It supports easy rollbacks to previous versions of applications, enhancing the reliability of deployments.

7. Community and Ecosystem

Growing Ecosystem: Being part of the ArgoCD ecosystem means that Autopilot benefits from a vibrant community and ongoing improvements.

Considerations

Learning Curve: While Autopilot simplifies many processes, there might still be a learning curve for teams unfamiliar with GitOps or the specific conventions of ArgoCD.
Customization: The opinionated structure may require adjustments for projects that have unique requirements or workflows.

Conclusion

ArgoCD Autopilot is a powerful addition for teams looking to implement GitOps practices effectively. It can greatly reduce the operational burden of managing Kubernetes applications while ensuring consistency and best practices. If your team is adopting ArgoCD, leveraging Autopilot can enhance your workflow and help you get the most out of your GitOps implementation.

If you're considering using ArgoCD Autopilot, I'd be happy to help with the setup or any specific questions you might have!

To start using ArgoCD Autopilot in your Minikube setup, follow these steps:

1. Install ArgoCD Autopilot

First, ensure you have the ArgoCD Autopilot CLI installed. You can download the latest version from the ArgoCD Autopilot GitHub releases page.

For example, on a Unix-like system, you can install it using:

curl -sSL https://github.com/argoproj-labs/argocd-autopilot/releases/latest/download/argocd-autopilot-linux-amd64 -o argocd-autopilot
chmod +x argocd-autopilot
sudo mv argocd-autopilot /usr/local/bin/

2. Set Up Your Git Repository

Create a Git repository for your applications. This repository will store your application configurations managed by ArgoCD Autopilot. You might structure it like this:

your-git-repo/
├── apps/
│   └── httpd/
│       ├── app.yaml
│       └── ...
├── clusters/
│   └── minikube/
│       ├── app.yaml
│       └── ...
└── README.md

3. Initialize Autopilot in Your Repository

Navigate to your repository's root directory and initialize ArgoCD Autopilot:

cd your-git-repo
argocd-autopilot init

This command creates the necessary files and directories for managing your applications.

4. Create Your Application with Autopilot

Create a new application (e.g., for httpd) using Autopilot. Run the following command:

argocd-autopilot app create httpd \
  --repo your-git-repo-url \
  --path apps/httpd \
  --dest-namespace default \
  --dest-server https://kubernetes.default.svc

Replace your-git-repo-url with your actual Git repository URL.
This command generates an application configuration in apps/httpd/app.yaml.

5. Add Your Application Configuration

Edit apps/httpd/app.yaml to define your httpd application. Here's a simple example for an HTTPD deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpd
  labels:
    app: httpd
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpd
  template:
    metadata:
      labels:
        app: httpd
    spec:
      containers:
      - name: httpd
        image: httpd:latest
        ports:
        - containerPort: 80

---
apiVersion: v1
kind: Service
metadata:
  name: httpd
spec:
  selector:
    app: httpd
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

6. Deploy the Application

Once you have configured your application, commit and push your changes to your Git repository:

git add .
git commit -m "Add httpd application"
git push origin main

7. Register Your Git Repository with ArgoCD

You need to add your Git repository to ArgoCD so it can monitor your applications:

argocd repo add your-git-repo-url --username <username> --password <password>

8. Sync Your Application with ArgoCD

Now, you can create the application in ArgoCD using the following command:

argocd app create httpd \
  --repo your-git-repo-url \
  --path apps/httpd \
  --dest-namespace default \
  --dest-server https://kubernetes.default.svc

To sync the application, run:

argocd app sync httpd

9. Access the Application

To access the httpd service, you can use the Minikube service command:

minikube service httpd

This will open the service in your default web browser.

Summary

Installation: Install the ArgoCD Autopilot CLI.
Git Setup: Create and initialize a Git repository for your application configurations.
Application Creation: Use Autopilot to create an application configuration for httpd.
Deployment: Push your changes to Git, register the repository with ArgoCD, and sync the application.

With these steps, you should be able to set up ArgoCD Autopilot in your Minikube environment effectively. If you have any specific configurations or adjustments in mind, let me know!

sommerfeld-io / vm-ubuntu-desktop