This article outlines a comprehensive approach to automating Kubernetes cluster deployment, focusing on efficiency and consistency. It details a method for setting up a robust, production-ready Kubernetes environment using a suite of powerful DevOps tools.

Automated Kubernetes Cluster Deployment: A Deep Dive

This phase of the project is dedicated to streamlining the entire Kubernetes cluster installation and configuration process. Key aspects covered include:

• Automated Installation: Leveraging kubeadm for seamless Kubernetes cluster setup.
• Node Configuration: Preparing both master and worker nodes, specifically integrating the containerd runtime for container management.
• Network Module Preparation: Setting up essential network modules optimized for future Istio integration.
• Secure Authentication: Implementing SSH key management to ensure passwordless authentication across the cluster.
• Cluster Validation: Verifying the cluster’s operational status and correctly setting up kubeconfig for access.
• Task Automation: Utilizing go-task (Task) to automate various operational tasks, enhancing workflow efficiency.

Core Technologies Utilized:

The automation relies on a powerful technology stack:

• Ansible (2.9+): The primary automation engine for provisioning and configuration management.
• Kubernetes (kubeadm): The open-source system for automating deployment, scaling, and management of containerized applications.
• Containerd Runtime: A high-performance, industry-standard container runtime that forms the core of the container infrastructure.
• Task (go-task): A task runner designed for simplicity and automation, orchestrating complex operations.
• Ubuntu Server 24.04 LTS: The chosen operating system for the cluster nodes.
• Python 3.13: The scripting language underpinning Ansible’s functionality.

Project Structure and Organization:

The project employs a well-structured Ansible directory layout, promoting modularity and maintainability:

• ansible.cfg: Global Ansible configurations.
• site.yaml: The main Ansible playbook, orchestrating the entire deployment.
• Taskfile.yml: Defines automated tasks managed by go-task.
• inventory/: Contains hosts.ini for host definitions and group_vars/all.yaml for global variables.
• roles/: Houses specific Ansible roles for prepare-nodes, configure-master-node, configure-worker-node, kubeconfig, and an optional reset-vm role.
• collections/requirements.yaml: Specifies required Ansible collections.
• output/: Stores execution logs and generated output files like kubeconfig.

Detailed Workflow and Cluster Architecture:

The deployment follows a logical progression, beginning with node preparation and culminating in a fully operational Kubernetes cluster. The cluster architecture is defined as:

• Master Node: A single control plane node (e.g., 192.168.100.220).
• Worker Nodes: Two worker nodes to host workloads (e.g., 192.168.100.223, 192.168.100.224).
• Runtime: containerd as the container runtime.
• Network: Pre-configured to support Istio service mesh.

Configuration Essentials:

• Inventory Configuration: Defines master and worker nodes with their respective IP addresses.
• Global Variables (all.yaml): Sets parameters such as os, arch, ansible_user, ansible_ssh_private_key_file, and enables ansible_become for elevated privileges.

Practical Usage Steps:

1. Prerequisites Setup: Install go-task (e.g., via Homebrew on macOS), install Ansible collections from requirements.yaml, and set up SSH keys for passwordless access to all nodes using ssh-copy-id.
2. Testing (Dry Run): Execute task test:all, task test:site:master, or task test:site:worker to validate configurations without making changes.
3. Full Deployment: Run task apply:all for a complete deployment, or task apply:site followed by task apply:kubeconfig for a step-by-step approach.
4. Direct Ansible Alternative: For direct control, verify connectivity with ansible all -i inventory/hosts.ini -m ping and deploy using ansible-playbook site.yaml -i inventory/hosts.ini.

Ansible Roles Breakdown:

Each Ansible role plays a critical part in the deployment:

• prepare-nodes: Handles initial system configurations like disabling swap, configuring kernel modules (overlay, br_netfilter), installing and setting up containerd, preparing for Istio/Kubeflow, and installing kubeadm, kubelet, and kubectl.
• configure-master-node: Initializes the Kubernetes cluster using kubeadm, configures networking, and generates join tokens for worker nodes.
• configure-worker-node: Enables worker nodes to join the cluster and configures kubelet on them.
• kubeconfig: Manages the retrieval and setup of kubeconfig files for cluster access.

Outputs and Verification:

Upon successful deployment, the output/ directory will contain timestamped execution logs and the kubeconfig file. Cluster verification involves copying the kubeconfig locally and using kubectl get nodes, kubectl get pods -A, and kubectl cluster-info to confirm the cluster’s health and node status. An expected output would show master and worker nodes in a “Ready” state.

Task Automation Features:

go-task simplifies operations with available commands like task init for logging setup, task test:all for dry runs, task apply:all for full deployment, task apply:site for the main playbook, and task apply:kubeconfig for kubeconfig setup. Automated logging provides timestamped, structured output for verbose execution tracking.

Troubleshooting and Reset:

Common issues are addressed with commands like ansible all -i inventory/hosts.ini -m ping for connectivity checks, manual swap disable (sudo swapoff -a, sudo sed -i '/ swap / s/^/#/' /etc/fstab), and verbose Ansible execution (ansible-playbook site.yaml -i inventory/hosts.ini -vvv). An optional cluster reset feature is available by uncommenting the reset-vm role and running the playbook with --tags reset.

What’s Next?

With the foundational Kubernetes cluster automated and operational, the subsequent steps involve deploying CNI plugins like Calico and configuring a service mesh, such as Istio, to enhance networking and traffic management capabilities.

The Complete StackOpsys Journey:

This automated Kubernetes cluster deployment is part of a larger “StackOpsys Journey,” a multi-part series designed to build a complete operational stack. Previous parts covered custom VM templates with Packer and infrastructure provisioning with Terraform. The full project and its code are openly available on GitHub at github.com/rtaparay/stackopsys.