DEV Community: Isaac kumi

Configure SSL for Free with Let's Encrypt

Isaac kumi — Mon, 22 Jan 2024 14:29:05 +0000

Update the Snap application, which is used to download application bundles. Snap comes pre-installed on Ubuntu 22.04.

sudo snap install core && sudo snap refresh core

Remove the default Ubuntu Certbot installation.

sudo apt remove certbot

Install Certbot.

sudo snap install --classic certbot

Download a certificate for the domain using certbot

sudo certbot --apache

Enter domain name when asked eg: isaackumi.com

Elevate Your Workflow Automation with StackStorm: A Quick Docker Setup Guide

Isaac kumi — Thu, 16 Nov 2023 14:49:35 +0000

Introduction:
Automating workflows just got easier with StackStorm, a powerful open-source automation platform. In this guide, we'll walk you through setting up StackStorm using Docker and Docker Compose, providing a seamless experience for workflow development and execution.

Getting Started:

Clone the StackStorm Docker repository: ```shell

git clone https://github.com/stackstorm/st2-docker
cd st2-docker


2. Familiarize yourself with the directory structure:
   ![Folder structure](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/a2oozil5kqwdjt1w07bi.png)

3. Optionally, customize your setup by modifying variables in the `docker-compose.yml` file. Key options include:
   - `ST2_VERSION`: Tag for the Docker image.
   - `ST2_IMAGE_REPO`: Image or path to images (default is `stackstorm/`).
   - `ST2_EXPOSE_HTTP`: Port for exposing the st2web service (default is `127.0.0.1:80`).
   - `ST2_PACKS_DEV`: Directory for development packs (default is `./packs.dev`).

---

**Launching StackStorm:**
Execute the following command to start the containers:
```shell


docker-compose up -d

Inspect the running containers:

Accessing StackStorm UI:
Navigate to the UI at http://localhost/

Username: st2admin
Password: Ch@ngeMe

Configuration and CLI Access:

Configure your password in files/htpasswd.
Access the StackStorm CLI within the container: ```shell

docker-compose exec st2client bash

  ![StackStorm CLI](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/an84fzc4kq6x5pqdrt1d.png)

---

**Conclusion:**
With StackStorm up and running in Docker, you're ready to streamline your workflows. Explore the intuitive UI, harness the power of automation, and elevate your development experience. Happy automating!

---

*Feel the Pulse of Automation: Dive into StackStorm with Docker!*

Deploying ArgoCD on Minikube with Terraform and Helm: A Step-by-Step Guide

Isaac kumi — Thu, 19 Oct 2023 11:09:41 +0000

Prerequisites

Before diving into deploying ArgoCD on Minikube, make sure you have the following prerequisites installed on your system:

Docker
Minikube
Terraform
Helm
kubectl

For this guide, we're using a two-node cluster on Minikube, although one node should suffice.

Start Minikube with two nodes using this command:



minikube start --nodes 2 -p argocd-helm

Verify your Minikube setup with:



kubectl get nodes

Next, set up your project directory:



mkdir -p terraform/values
cd terraform && touch provider.tf main.tf
cd terraform/values && touch argocd.yaml

Now, let's configure Terraform to deploy ArgoCD using Helm.

terraform/provider.tf



provider "helm" {
  kubernetes {
    config_path = "~/.kube/config"
  }
}

terraform/main.tf



resource "helm_release" "argocd" {
  name = "argocd"

  repository       = "https://argoproj.github.io/argo-helm"
  chart            = "argo-cd"
  namespace        = "argocd"
  create_namespace = true
  version          = "3.35.4"

  values = [file("values/argocd.yaml")]
}

In terraform/values/argocd.yaml, you can override some default ArgoCD Helm chart values:



global:
  image:
    tag: "v2.6.6"

server:
  extraArgs:
  - --insecure

After setting up your Terraform configuration, execute the following commands in your terminal:



terraform init
terraform apply --auto-approve

Verify the ArgoCD deployment with:



kubectl get pods -n argocd

To access the ArgoCD web UI, you'll need to port forward to the argocd-server service:



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

Now, open your browser and navigate to localhost:8080. You should see the ArgoCD login page.

The default username is admin. Retrieve the password from the secret using:



kubectl get secrets argocd-initial-admin-secret -o yaml -n argocd

Copy the password and decode it with the base64 utility:



echo "copied_password_here" | base64 -d

Now, paste the decoded password without the % sign at the end into the password field on the login page.

Voila! You've successfully deployed ArgoCD on Minikube.

A Quick Introduction to Docker for Absolute Beginners

Isaac kumi — Mon, 09 Oct 2023 11:46:21 +0000

Are you new to containerization and wondering what all the buzz is about Docker? You're in the right place! Docker simplifies the process of developing, deploying, and managing applications. We'll introduce Docker for absolute beginners in this blog post.

What is Docker?
Docker is an open-source platform designed to make it easier to develop, deploy, and run applications using containers. Containers are lightweight, portable, and self-sufficient units that package an application and its dependencies, ensuring consistency and reproducibility across different environments.
Why Use Docker?
Some of the key benefits of using Docker:

Isolation: Containers isolate applications and their dependencies from the underlying system, averting conflicts and ensuring consistency.
Portability: Docker containers can run on any system that supports Docker, making it easy to move applications between different environments.
Scalability: Docker makes it simple to scale applications horizontally by running multiple containers, improving performance and reliability. ** Getting Started with Docker**

To begin your Docker journey, follow these simple steps:
1.** Installation**: Start by installing Docker on your machine. You can find installation instructions for various platforms on the Docker website.
For Mac and Windows, you should download the Docker Desktop onto your laptop.

2*. Docker Hub*: Docker Hub is a repository of pre-built container images that you can use to get started quickly. You can search for popular images or even publish your own.

Your First Docker Container

Once Docker is installed, open a terminal and run the following command to pull and run the "nginx" container:

 docker run nginx

This command will download the "nginx" image and run a container from it.

Here are some useful Docker commands you should know:

docker ps: This command lists all the running containers on your system. By default, it shows the container ID, image name, status, ports, and more.

   docker ps

docker ps -a: To view all containers, including stopped ones, you can use the -a flag.

   docker ps -a

docker images: This command lists all the Docker images you've pulled or created on your machine.

   docker images

docker pull: Use this command to download a Docker image from Docker Hub or another container registry.

   docker pull image_name

docker run: To start a new container, you can use the docker run command.

   docker run  nginx

docker stop: This command stops a running container by specifying its container ID or name.

   docker stop container_id_or_name

docker start: To restart a stopped container, you can use the docker start command.

   docker start container_id_or_name

Docker restart: This command stops and then starts a container, which can be useful for applying configuration changes.

   docker restart container_id_or_name

docker rm: To remove a stopped container, you can use the docker rm command. Be cautious, as this action is irreversible.

   docker rm container_id_or_name

docker rmi: To remove a Docker image from your local machine, use the docker rmi command. Make sure no containers are currently using the image you want to remove.
```
docker rmi image_name_or_id
```
docker exec: You can use this command to run a command inside a running container. This is useful for debugging or executing specific tasks within a container.
```
docker exec -it container_id_or_name command
```
docker logs: To view the logs of a running container, use the docker logs command.
```
docker logs container_id_or_name
```

Learning Resources: You can learn more about Docker by exploring the many tutorials, documents, and online courses that are accessible. Websites like the official Docker documentation and tools like Play with Docker are both excellent sources of information.
Aside from what we've covered here, keep in mind that Docker is a big ecosystem with many other features and possibilities. These fundamentals provide you with a strong starting point for your exploration and experimentation with Docker containers as a complete novice. Good luck containerizing!

Generate YAML Manifests with Ease! 🚀

Isaac kumi — Tue, 01 Aug 2023 17:14:52 +0000

🚀 Kubernetes Pro Tip: Generate YAML Manifests with Ease! 🚀

Are you tired of manually creating YAML manifests for your Kubernetes pods? Here's a handy trick to make your life easier! 😎

The kubectl run command is a powerful tool for deploying containers in Kubernetes. But did you know it can also help you generate YAML manifests effortlessly? 📋

Let's say you want to deploy an Nginx pod. Instead of crafting the YAML file from scratch, you can use the --dry-run flag to preview the YAML output without actually creating the pod. Here's how you can do it:

1️⃣ Open your terminal and ensure you have kubectl installed.

2️⃣ Use the following command:

kubectl run nginx --image nginx --dry-run=client -o yaml > pod-definition.yaml

3️⃣ Ta-da! You've just generated a YAML manifest named pod-definition.yaml for your Nginx pod.

The --dry-run flag prevents the pod from being created, and the -o yaml flag instructs kubectl to output the YAML representation of the resource.

Now, you can easily modify this YAML file to suit your specific needs. Adjust resource limits, add environment variables, or define volume mounts—all without starting from scratch! 🛠️

So, the next time you need to deploy a new pod, save time and effort by using kubectl run with --dry-run to create your YAML manifests like a pro! 💪

Happy YAML manifesting! 😄🎉

How I Passed the AWS DevOps Engineer Professional Exam: Resources and Tips

Isaac kumi — Mon, 17 Jul 2023 11:36:36 +0000

Introduction:
Passing the AWS DevOps Engineer Professional exam is a significant achievement for professionals in the field. In this blog post, I will share my experience and provide valuable resources and tips that helped me succeed.

Exam Overview:
The AWS DevOps Engineer Professional exam is designed to assess your knowledge and skills in various domains, including continuous delivery and automation, infrastructure as code, monitoring and logging, security, and more. Hands-on experience and practical knowledge are crucial for success.

Preparation Strategy:
To prepare for the exam, I followed a well-structured study plan. I allocated dedicated time each day for studying and hands-on practice. This allowed me to cover all the relevant topics and gain confidence in my abilities.

Recommended Resources:
During my preparation, I found the following resources to be highly valuable:

Acloud Guru: Acloud Guru offers comprehensive AWS training courses, including a specific course for the AWS DevOps Engineer Professional exam. Their well-structured content and hands-on labs provided a solid foundation for exam topics.
Stephane Mareek's DevOps Professional Course on Udemy: Stephane Mareek's course on Udemy is highly regarded in the DevOps community. His detailed explanations and practical examples helped me deepen my understanding of AWS DevOps concepts.
Official AWS Documentation: The official AWS documentation provides comprehensive coverage of AWS services, their features, and best practices. It is an essential resource for understanding the intricacies of various services and their integration.
AWS Whitepapers and FAQs: AWS whitepapers and FAQs are excellent sources for gaining in-depth knowledge about specific services and concepts. They provide insights into architectural patterns, design principles, and recommended practices.
Exam Readiness Training: AWS offers Exam Readiness training courses specifically tailored for the DevOps Engineer Professional exam. These courses provide detailed guidance on exam topics, key concepts, and sample questions.
Practice Exams: Taking practice exams is essential for familiarizing yourself with the exam format, identifying knowledge gaps, and improving time management skills. I used Tutorials Dojo and Whizlabs for their comprehensive and realistic practice exams.
Online Communities and Forums: Engaging with the DevOps community through online forums and communities can be immensely helpful. Discussions, tips, and shared experiences from professionals can provide valuable insights and additional resources.

Tips for Success:
To increase your chances of success, consider the following tips:

Focus on hands-on experience: Practical knowledge of deploying, managing, and troubleshooting AWS services is critical. Practice building and automating infrastructure using AWS tools and services.
Learn AWS best practices: Familiarize yourself with AWS's recommended architectural patterns, security practices, and service-specific best practices. Understanding these principles will help you answer questions related to designing secure and scalable solutions.
Time management during the exam: The exam duration is limited, so managing your time effectively is essential. Read each question carefully, eliminate obviously incorrect answers, and prioritize questions that you can answer confidently. Use the "Review" feature to revisit challenging questions before submitting.

** Mock Exams and Practice Questions:**
Taking mock exams and practicing with sample questions is highly recommended. These resources will help you identify weak areas and build your confidence. I used Tutorials Dojo and Whizlabs for their comprehensive practice exams that closely resemble the actual AWS exams.

Exam-Day Strategies:
On the day of the exam, ensure you get a good night's sleep and have a nutritious meal to optimize your focus and concentration. Arrive at the exam center early to minimize any unnecessary stress or rush.

Conclusion:
Preparing for and passing the AWS DevOps Engineer Professional exam requires dedication, hands-on experience, and access to reliable resources. By following a well-structured study plan, leveraging recommended resources, and practicing with mock exams, you can increase your chances of success. Best of luck in your exam preparation journey!

Resources Used:

Acloud Guru
Stephane Mareek's DevOps Professional Course on Udemy
Official AWS Documentation
AWS Whitepapers and FAQs
Exam Readiness Training
Tutorials Dojo (Mock Exam Provider)
Whizlabs (Mock Exam Provider)
Online Communities and Forums

Dockerizing a Flask Application: A Multi-Stage Dockerfile Approach

Isaac kumi — Tue, 11 Jul 2023 17:25:50 +0000

The provided code sets up a basic Flask application and Dockerfile for containerizing the application. Here's a brief comment on each part of the code:

# project setup
mkdir app
cd app
touch app.py
touch Dockerfile
touch requirements.txt

This snippet creates the necessary files and directories for the project. It creates a directory named app, then creates files app.py, Dockerfile, and requirements.txt within the app directory.

Flask

The requirements.txt file lists the dependencies required by the Flask application. In this case, it only includes the Flask dependency.

from flask import Flask
import os

app = Flask(__name__)

@app.route('/')
def hello():
    return f'Hello, World!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

The app.py file contains a simple Flask application. It imports the Flask module, creates an instance of the Flask class, defines a route for the root URL ("/"), and returns a "Hello, World!" message when the route is accessed.


# Stage 1: Build stage
FROM python:3.9 as builder

WORKDIR /app

# Copy requirements.txt to the container
COPY requirements.txt .
RUN pip install --upgrade pip
RUN pip install --upgrade setuptools wheel

# Install dependencies
RUN pip install --no-cache-dir --upgrade -r requirements.txt

# Copy the application source code
COPY . .
RUN rm requirements.txt

# Stage 2: Production stage
FROM builder

WORKDIR /app

# Copy the installed dependencies from the previous stage
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages

# Copy the application source code from the previous stage
COPY --from=builder /app/* .

# Expose port 5000
EXPOSE 5000

CMD ["python","app.py"]

The Dockerfile is divided into two stages. The first stage, named builder, sets up the build environment. It copies the requirements.txt file, upgrades pip, and installs the required dependencies. Then, it copies the application source code and removes the requirements.txt file.

The second stage, which is the production stage, inherits from the builder stage. It sets the working directory, copies the installed dependencies from the builder stage, and copies the application source code. The EXPOSE instruction exposes port 5000, and the CMD instruction specifies the command to run the application.

conclusion

One of the key benefits of using a multi-stage Dockerfile approach is the ability to create more optimized and efficient Docker images.

Smaller Image Size and Enhanced Security: With multi-stage builds, you can significantly reduce the size of the final Docker image. By separating the build environment from the runtime environment, only the necessary artifacts and dependencies are included in the production stage. This optimization results in smaller image sizes, which reduces disk space usage and speeds up image transfers. Additionally, by excluding build tools and dependencies from the final image, you minimize potential security risks. This approach ensures that only the essential components required for running the application are present, reducing the attack surface and enhancing the overall security posture of your containerized Flask application.

By incorporating a multi-stage Dockerfile into your containerization process, you can reap the benefits of smaller image sizes, improved security, and faster builds. This approach is particularly advantageous for large-scale projects and scenarios where optimizing image size and reducing security vulnerabilities are critical factors.

Setting up a single or multi-Node Cluster on KinD

Isaac kumi — Tue, 11 Jul 2023 11:23:51 +0000

Introduction

Welcome, fellow tech adventurers! Today, we're about to embark on an exciting journey into the wonderful world of Kind clusters. So buckle up, tighten your seatbelts (metaphorically, of course), and get ready for an epic quest to conquer the realm of container orchestration. Together, we'll navigate the treacherous seas of setup and configuration to emerge victorious with our very own Kind cluster. Are you ready? Let's dive in!

Every great adventure needs a hero, and you, my friend, are about to become one! But first things first: What on earth is a Kind cluster? Well, Kind, short for Kubernetes IN Docker, is a fantastic tool that enables you to run local Kubernetes clusters using Docker containers. It's like having a pocket-sized version of Kubernetes right at your fingertips. Impressive, right?

Gearing Up for the Journey

Before setting off on our grand adventure, we need to make sure we have all the necessary tools and provisions. Don't worry; we won't need a sword or a suit of armor (unless you really want to dress up for the occasion). The essentials for this quest include Docker, kubectl (the Kubernetes command-line tool), and, of course, a dash of patience and a sprinkle of curiosity. With these tools in hand, we're ready to conquer the Kind cluster universe!

Unveiling the Treasure Map: Installation

Ah, the thrill of discovery! The first step in our grand adventure is to install Kind itself. Fear not, brave traveler, for this part is surprisingly simple. Just run the provided commands in your terminal, and Kind will be up and running, ready to unleash its containerized magic.

curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.11.1/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

Remember to take a moment to revel in your achievement because, my friend, you're now the proud parent of a Kind cluster!

Configuring the Gem: Cluster Setup

Now that we have our Kind cluster at our beck and call, it's time to tailor it to our needs. Cluster configuration is where the real fun begins. We get to decide the number of worker nodes, choose the Kubernetes version, and even customize networking options. It's like playing a video game where you're the game master, architect, and rule-breaker all at once. Trust me; this is where your inner tech wizard can truly shine!

To create a single node Kind cluster, run the following command:

kind create cluster

kind create cluster --name test-cluster

For a multi-node cluster, use a config file to add extra nodes.

vi cluster-config.yaml

# A sample multi-node cluster config file
# A three node (two workers, one controller) cluster config
# To add more worker nodes, add another role: worker to the list
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: test-cluster
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"    
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
- role: worker
- role: worker

Then run the cluster config file

kind create cluster --config cluster-config.yaml

Unleashing the Magic: Interacting with Your Kind Cluster

Now that our Kind cluster is up and running, let's tap into its immense power. With kubectl as our trusty companion, we can deploy applications, manage pods, and even perform awe-inspiring scaling tricks. Your Kind cluster is like a stage, and kubectl is your backstage pass to control and orchestrate the most dazzling performances. Prepare to be amazed as you witness the seamless integration of containers and Kubernetes!

verify your setup by using the following command

kubectl get nodes
kubectl get po

➜  ~ kubectl get nodes
NAME                 STATUS   ROLES           AGE   VERSION
kind-control-plane   Ready    control-plane   36h   v1.25.3
➜  ~

Conclusion: Your Adventure Begins Now!

Congratulations, intrepid explorer! You've successfully set up your very own Kind cluster, and your journey into the world of container orchestration has only just begun. But remember, this is only the first step on a thrilling path filled with countless opportunities for growth and learning. So embrace the challenges, celebrate your victories (big or small), and always keep that jovial spirit alive as you embark on your adventures with Kind clusters. Happy clustering!

Resources:

Kind Documentation: https://kind.sigs.k8s.io/
Kubernetes Documentation: https://kubernetes.io/docs/home/
Docker Documentation: https://docs.docker.com/