DEV Community: Chinaza Otumba

How to Create Your First API with Python, Flask and Azure

Chinaza Otumba — Mon, 03 Feb 2025 05:02:30 +0000

Introduction

APIs (Application Programming Interfaces) are the backbone of modern software development, enabling different applications to communicate with each other efficiently. They allow seamless data exchange between systems, automating processes that would otherwise require manual intervention. From fetching real-time weather data to processing payments and integrating third-party services, APIs are essential tools for developers.

In this beginner-friendly guide, we will create a simple API using Python and Flask a lightweight and easy-to-use web framework for Python that allows developers to create APIs and web applications quickly. This API will take a number as input and return some basic properties, such as whether it is even or odd, and its square. We will also deploy the API so that it can be accessed from anywhere.

Understanding APIs

Before diving into the implementation, let’s take a step back and understand APIs at a higher level.

What is an API?

An API acts as a bridge between different software applications, allowing them to communicate with each other. It acts as a middleman, handling requests and responses between a client (like your phone or a website) and a server (where data or services live). For example, you walk into a coffee shop and order a latte. You don’t go behind the counter and make it yourself—you just tell the barista what you want.

Here’s how an API works in this scenario:

You (the client) order a latte.
The barista (API) takes your order and communicates it to the kitchen (server).
The kitchen (server) makes your latte.
The barista (API) brings it back to you.

You don’t need to know how the coffee is brewed or what machine they use—you just get your latte.

How This Relates to APIs:

The barista is the API—they handle requests and deliver responses.
The kitchen is the backend server where all the work happens.
The customer (you) is the client making a request.

APIs help different apps and services interact without knowing the complex inner workings—just like you don’t need to be a barista to order coffee!

API architectural styles

APIs often use JSON or XML format to send and receive data and APIs can be categorized into various architectural styles, including RESTful APIs, GraphQL APIs, and SOAP APIs.

They also follow a set of rules called HTTP methods, such as::

GET – Retrieve data.
POST – Send data to create a new resource.
PUT – Update an existing resource.
DELETE – Remove a resource.

In this guide, we will use the GET method to allow users to request information about a number.

Project Overview

Our API will:

Accept a number as input via a GET request.
Check if the number is even or odd.
Calculate the square of the number.
Return results in JSON format.
Be deployed online using Azure App Services.

Prerequisites

Before starting, ensure you have:

Python 3+ installed.
Flask installed (pip install flask).
A GitHub account to host the project.
An Azure account for deployment.

Step 1: Setting Up the Project

Create a project directory:

   mkdir simple-api && cd simple-api

Install Flask:

   pip install flask

Step 2: Implementing the API

Create a Python file (app.py) and add the following code:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/api/number-info', methods=['GET'])
def number_info():
    num = request.args.get('number')

    if not num or not num.isdigit():
        return jsonify({"error": "Invalid input. Please provide a valid number."}), 400

    num = int(num)
    response = {
        "number": num,
        "even_or_odd": "even" if num % 2 == 0 else "odd",
        "square": num ** 2
    }
    return jsonify(response)

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

Step 3: Running the API Locally

Save the file and start the API:

python app.py

Test it using:

curl "http://127.0.0.1:5000/api/number-info?number=4"

Expected Response:

{
    "number": 4,
    "even_or_odd": "even",
    "square": 16
}

Step 4: Deploying the API to Azure

You can deploy this API using Azure App Services by following these steps:

Install Azure CLI:

   pip install azure-cli

   az login

Create a resource group (if not already created):

   az group create --name myResourceGroup --location eastus

Deploy the API directly:

   az webapp up --name simple-api --resource-group myResourceGroup --runtime PYTHON:3.8

Test it using the URL provided:

curl "http://127.0.0.1:5000/api/number-info?number=4"

(Optional) If using GitHub, push your code to a repository(replace my repo URL with yours):

   echo "# pythonapi1" >> README.md
   git init
   git add README.md
   git commit -m "first commit"
   git branch -M main
   git remote add origin https://github.com/Obs3rve/pythonapi1.git
   git push -u origin main

Conclusion

This guide introduced the fundamentals of building an API using Python and Flask. We created a simple API that accepts a number, determines if it is even or odd, and calculates its square. Finally, we deployed it on Azure.

In the next guide, we will enhance this API by allowing it to analyze numbers in more depth. The API will not only check if a number is prime but also return additional interesting mathematical properties about it, along with a fun fact.

Stay tuned for the next guide! 🚀

Setting Up an NGINX Web Server on Azure: My DevOps HNG Stage 0 Experience

Chinaza Otumba — Mon, 03 Feb 2025 02:56:35 +0000

Introduction

As part of the HNG DevOps internship, I completed Stage 0: NGINX Configuration by installing and configuring an NGINX web server on an Ubuntu machine. This blog post provides a guide, detailing my approach, challenges faced, solutions implemented, and key takeaways from this task.

Task Overview

The objective of this task was to:

Install and configure NGINX on an Ubuntu server.
Replace the default NGINX page with a custom HTML file displaying: Welcome to DevOps Stage 0 - [Your Name]/[SlackName]
Ensure the page is accessible via a public IP address.

Step-by-Step Approach

1️⃣ Setting Up the Ubuntu Server on Azure

Since the task required a fresh Ubuntu instance, I deployed an Ubuntu 22.04 virtual machine on Microsoft Azure following these steps:

Logged into the Azure Portal.
Navigated to Virtual Machines and selected Create > Azure Virtual Machine.

Selected Ubuntu 22.04 LTS as the OS and Configured the machine.

Configured Inbound Port Rules, initially allowing only SSH (port 22), which later caused accessibility issues.

After deployment, copied the Public IP Address and connected via SSH:

   ssh username@my-server-ip

2️⃣ Updating the System

Before installing any software, I updated the system to ensure the latest security patches and package versions:

sudo apt update && sudo apt upgrade -y

3️⃣ Installing NGINX

To install and verify NGINX:

sudo apt install nginx -y
sudo systemctl status nginx

If the service isn't running, start it manually but in case I didn't need to do this:

sudo systemctl start nginx

To ensure NGINX starts automatically at boot, enable the service:

sudo systemctl enable nginx

4️⃣ Configuring the Custom Web Page

To meet the task requirements, I modified the index.html file:

sudo nano /var/www/html/index.html

Replaced the default content with:

<!DOCTYPE html>
<html>
<head>
    <title>Welcome</title>
</head>
<body>
    <h1>Welcome to DevOps Stage 0 - [Your Name]/[SlackName]</h1>
</body>
</html>

After saving the file, I restarted NGINX:

sudo systemctl restart nginx

5️⃣ Configuring Inbound Port Rules on Azure

Initially, I couldn't access the web page due to inbound rule restrictions. I resolved this by allowing HTTP (port 80) traffic.

Using the Azure Portal:

Navigated to Virtual Machines > Selected my VM > Networking > Network settins.
Clicked Create port rule.
Set Destination Port to 80, Protocol to TCP, and Action to Allow.
Save the changes.

6️⃣ Testing the Web Page

I confirmed the setup by opening a browser and visiting:

http://my-server-ip:80

The custom message successfully displayed, indicating a successful configuration.

Challenges & Solutions

🔴 Challenge 1: Choosing the Right Server and Public IP Availability

issue: The first challenge I faced was deciding which server to use for this project. Initially, I considered using my Raspberry Pi, but I encountered difficulties with obtaining a stable public IP address due to ISP restrictions.

Solution: To overcome this, I opted for Microsoft Azure, which provides a reliable public IP by default, ensuring seamless deployment and accessibility.

🔴 Challenge 2: Configuring Inbound Ports on Azure

Issue: I initially allowed only SSH traffic, preventing access to NGINX.

Solution: I modified the network security group settings to allow inbound traffic on port 80 via both the Azure portal and CLI.

Key Takeaways

This project provided invaluable hands-on experience with:

Cloud Infrastructure: Setting up an Ubuntu VM on Azure.
Linux Server Management: Handling SSH connections and package management.
Web Server Configuration: Installing and managing NGINX.
Networking & Security: Configuring inbound rules to allow web traffic.
Troubleshooting: Debugging issues related to firewall rules and NGINX status.

How This Task Helps My DevOps Journey

Completing this task gave me practical experience in Linux system administration, networking, and troubleshooting—fundamental DevOps skills. I also improved my ability to document configurations and resolve real-world deployment challenges.

Conclusion

This experience improved my ability to set up, configure, and troubleshoot web servers while reinforcing best practices for cloud security and networking. Looking forward to more HNG tasks! 💪

Beginners Guide to ReactJS — Data handling Using Props and State

Chinaza Otumba — Sun, 04 Feb 2024 10:08:00 +0000

Data Handling in React

If you’re reading this, you’ve already done your homework and are probably interested in understanding more about Reactjs.

So let’s cut to the chase: how can data be handled in react using Props and States?

ReactJS is one of the most popular JavaScript libraries for building user interfaces and it was created by Facebook.

There are two major ways data can be managed or handled in React and they are Prop and State. Understanding how they both work will be a huge leap toward learning React.

In this article, we are going to discuss

Briefly about components.
The characteristics of both prop and state.

Before diving into this let’s briefly discuss a key part of react, Components.

What are Components?

A component in react lets you split the elements or sections of your UI into independent, reusable pieces, and think about each piece separately.

An example would be if we were to develop Instagram, the like button, the comments, the share, the feed all would be individual components.

The components of React will get rendered or displayed if there is any change in state or props. Every component has a state and it’s only used to store values while Props are used to pass data from parent component to child component.

Parent and Child

You’ve probably heard people say things like you look so much like your dad, mom or even your grandparents. This is cause the child inherited their parent’s features such as hair color, complexion, etc.

I don’t think you’ve heard someone say the parent inherited some features from the child.

Now let’s relate it to this article.

As mentioned earlier data in Reactjs flows from parent to child as parents can’t inherit from their children

The parent passes the information down as “props”, (the properties) to the child file.

Keep reading, props are discussed better later in the article.

Functional Component

function Mango() {

return

Hello, I love Mangos.
;
}

These types of components are called “function components or functional components” because they are JavaScript functions.

Functional components are shorter and the implementation of setState() in functional-based components is shorter, easier, and with less boilerplate code. They are also easier to understand.

More on setState() later in the article

Class Component

import React from “react”;

class Mango extends React.Component {

render() {

return

Hello, I love Mangos.
;
}

}

As seen in the above code all class components must include the extends React.Component statement. This statement creates an inheritance to React.Component, and gives your component access to React.Component’s functions.

Now we understand what components are, let us get into Props.

What are Props?

Props simply mean properties and they are generally used to pass data from one component to another or from one parent component to its child component.

Characteristics of Props:

Props pass from parent to child component as React’s data flow between components is uni-directional.
Props are set for the children.
Props are read-only.
Props are used in both functional and class components.

“Props are Read-Only”

Props are immutable. Meaning once props are set they can not be changed or modified.

A component must never modify its own prop even if it was declared as a function or a class.

Example:

Consider this sum function:

function sum(a, b) {

. return a + b;

}

Functions similar to the above are called “pure” because they do not attempt to change their inputs, and always return the same result for the same inputs.

State

State is only used to store the internal values or property of a component, which affects that component only. When the state changes the component had to render again. Unlike prop, state can be modified but they cannot be passed from one component to the other. State should not be modified directly, it is modified with a special method called setState( ).

Using the this.state.propertyname syntax you can refer to state anywhere in the component.

Characteristics of State:

State is initialized inside the component’s constructor method.
State typically can only be used in class components but with the introduction of React hooks can be used in functional components as well.
State can not be accessed from outside of the component but the value can be passed via props.

Example:

class GreetingComponent extends React.Component {

constructor(props) {

super(props);

this.state = { name: “Olajumoke” };

}

render() {

return

Hello, {this.state.name}
;
}

}

Let’s update the state variable using setState()

class GreetingComponent extends React.Component {

constructor(props) {

super(props);

this.state = { name: “Olajumoke” };

}

componentDidMount() {

// following code updates the state

// your component will call the render method

// so that your changes can be seen in your dom

this.setState({ name: “Laurel” });

}

render() {

return

Hello, {this.state.name}
;
}

}

Quick Summary

So far we have learnt a lot about props and states. We now know that props cannot be changed while states on the other hand can be changed using a special method called setState().

Implementation of a Prototype Kubernetes-Based Cluster for Scalable Web-Based WordPress Deployment using K3s on Raspberry Pis

Chinaza Otumba — Sun, 04 Feb 2024 09:19:54 +0000

Welcome to an exhilarating journey where we unlock the secrets of building a scalable infrastructure using Kubernetes. In this comprehensive guide, we'll navigate the nuances of setting up a robust cluster to host a WordPress site. Buckle up as we explore the implementation process using five Raspberry Pis, a router, and a switch, with the lightweight K3s as our chosen Kubernetes distribution.

Setting the Stage: Objectives

Our primary goal is crystal clear – to create a powerhouse infrastructure that effortlessly scales to host a WordPress site. This guide will walk you through every twist and turn, from the initial Raspberry Pi setup to deploying and scaling your WordPress application.

Before diving into the implementation, ensure you have the following:

Hardware:
- Five Raspberry Pis(You can follow along with one Raspberry PI A similar setup can be found in this youtube video)
- Router and Switch
- SD Cards for Raspberry Pis
- Ethernet Cables
- Power Supply for Raspberry Pis
- External Drive (for storing disk images)
Software:
- Win32 Disk Imager (for disk imaging)
- K3s binary for ARM architecture (compatible with Raspberry Pi)
- Raspberry Pi OS Lite 64-bit
Knowledge:
- Basic understanding of Linux environments
- Basic understanding of Kubernetes with essential commands
- Fundamental networking knowledge

Setting Up Raspberry Pis
- 1.1 Hardware Preparation
- 1.2 Operating System Installation
- 1.3 Configuring Network Settings
- 1.4 Enabling SSH Access
Configuring the Master Node
- 2.1 Installing K3s on the Master Node
- 2.2 Verifying K3s Installation
- 2.3 Configuring Master Node Components
Setting Up Worker Nodes
- 3.1 Installing K3s on Worker Nodes
- 3.2 Joining Worker Nodes to the Cluster
- 3.3 Verifying Worker Node Status
Network Configuration
- 4.1 Configuring Raspberry Pi Networking
- 4.2 Ensuring Network Connectivity
- 4.3 Troubleshooting Network Issues
Persistent Volume Implementation
- 5.1 Creating Persistent Volumes
- 5.2 Configuring Persistent Volume Claims
- 5.3 Testing Persistent Volumes
Deploying WordPress on Kubernetes
- 6.1 Creating WordPress Deployment YAML
- 6.2 Configuring Service for WordPress
- 6.3 Verifying WordPress Deployment
Scaling the WordPress Deployment
- 7.1 Horizontal Pod Autoscaling
- 7.2 Testing Autoscaling
- 7.3 Analyzing Scalability
Monitoring and Observability
- 8.1 Implementing Prometheus for Monitoring
- 8.2 Grafana Dashboard Configuration
- 8.3 Observing Cluster Metrics

1. Setting Up Raspberry Pis

1.1 Hardware Preparation

Before we dive into the technical details, let's ensure that we have everything ready. Power up your Raspberry Pis and ensure they are properly connected to the network.

1.2 Operating System Installation

The first step is to get the Raspberry Pi OS up and running. To do this, follow these steps:

Download the Raspberry Pi Imager and install it on your computer.
Insert the SD card into your computer using an SD card reader.
Open the Raspberry Pi Imager and choose the Raspberry Pi OS Lite 64-bit version.
Select the inserted SD card as the storage location.
Click on "Write" to start the installation process.

Once the process is complete, eject the SD card safely and insert it into the Raspberry Pi.

1.3 Configuring Raspberry Pi Networking

Now, let's configure the network settings on each Raspberry Pi:

Boot up the Raspberry Pi:
- Connect a monitor, keyboard, and mouse to the Raspberry Pi.
- Power it up and follow the on-screen instructions to set up the Raspberry Pi OS.
Open the Terminal:
- Once the Raspberry Pi OS is booted, open the terminal.
Configure Network Settings:
- Use the following command to edit the network configuration file:
```
 sudo nano /etc/network/interfaces
```

Update the file with your desired network settings. For example:

 auto eth0
 iface eth0 inet static
 address 192.168.1.2
 netmask 255.255.255.0
 gateway 192.168.1.1

Save and Exit:
- Save the changes by pressing Ctrl + X, then Y to confirm, and finally Enter to exit.
Restart the Network:
- Restart the network interface to apply the changes:
```
 sudo systemctl restart networking
```

1.4 Enabling SSH Access

Enabling SSH on each Raspberry Pi is essential for remote access. Here's how you can do it:

Open the Raspberry Pi Configuration:
- Run the following command:
```
 sudo raspi-config
```

Navigate to Interfacing Options and enable SSH.

Restart the Raspberry Pi:
- After enabling SSH, restart the Raspberry Pi to apply the changes:
```
 sudo reboot
```

With these steps completed, you've successfully set up the Raspberry Pis for further configuration.

2. Configuring the Master Node

2.1 Installing K3s on the Master Node

Now, let's move on to configuring the master node. Follow these steps:

Log into the Master Pi:
- Open a terminal or use SSH to log into the master Raspberry Pi.
Download and Install K3s:
- Use the following command to download and install K3s:
```
 curl -sfL https://get.k3s.io | sh -
```
Verify K3s Installation:
- Once the installation is

complete, verify that K3s is running:

 ```bash
 sudo k3s kubectl get nodes
 ```

During installation, I got this error

Kubernetes requires “cgroup_memory=1 cgroup_enabled=memory” added to the cmdline.txt file of my pi’s for the installation to work. As this is missing the installation initially failed.

After adding this, I was able to install Kubernetes on the master node

2.2 Configuring Master Node Components

With K3s installed, configure the master node components:

Export Kubeconfig:
- Export the Kubeconfig file to enable kubectl commands:
```
 export KUBECONFIG=/etc/rancher/k3s/k3s.yaml
```
Check Nodes:
- Ensure that the master node is ready:
```
 sudo k3s kubectl get nodes
```

Install Helm:
- Helm is a package manager for Kubernetes. Install Helm using:
```
 sudo snap install helm --classic
```

Initialize Helm:
```
 helm init
```
Verify the Helm installation:
```
 helm version
```

With the master node configured, you're ready to proceed to the next stage.

3. Setting Up Worker Nodes

3.1 Installing K3s on Worker Nodes

Expand your cluster by setting up worker nodes. Here's how:

Log into Each Worker Pi:
- Use SSH to log into each worker Raspberry Pi.

Download and Install K3s:

Similar to the master node, install K3s on each worker node:

 curl -sfL https://get.k3s.io | K3S_URL=https://<master-node-ip>:6443 K3S_TOKEN=<node-token> sh -

Replace <master-node-ip> with the IP of your master node and <node-token> with the token obtained from the master node:
```
 sudo cat /var/lib/rancher/k3s/server/node-token
```

3.2 Joining Worker Nodes to the Cluster

After installing K3s on each worker node, join them to the cluster:

Obtain Master Node Token:
- On the master node, retrieve the token:
```
 sudo cat /var/lib/rancher/k3s/server/node-token
```

Join Worker to Cluster:

On each worker node, join the cluster using the token:

 curl -sfL https://get.k3s.io | K3S_URL=https://<master-node-ip>:6443 K3S_TOKEN=<node-token> sh -

3.3 Verifying Worker Node Status

Check if the worker nodes have successfully joined the cluster:

On the Master Node:
- Run the following command to verify the status of worker nodes:
```
 sudo k3s kubectl get nodes
```

Ensure all nodes are in the 'Ready' state.

With the worker nodes in place, your Kubernetes cluster is shaping up. Now, let's delve into network configuration.

4. Network Configuration

4.1 Configuring Raspberry Pi Networking

A well-configured network is crucial for the seamless operation of your Kubernetes cluster. Follow these steps to ensure optimal network settings:

Check Network Interfaces:
- Verify the available network interfaces on each Raspberry Pi:
```
 ip a
```

Identify the primary network interface (e.g., eth0) for configuration.

Edit Network Configuration File:
- Open the network configuration file for editing:
```
 sudo nano /etc/network/interfaces
```
Configure Static IP Address:
- Add the following lines to set a static IP address (adjust values based on your network):
```
 auto eth0
 iface eth0 inet static
 address 192.168.1.2
 netmask 255.255.255.0
 gateway 192.168.1.1
```

Save and exit the editor (press Ctrl + X, then Y, and Enter).

Restart Networking:
- Apply the changes by restarting the network service:
```
 sudo systemctl restart networking
```

This can also be set up on your router. Irrespective of how you set the Static IPs this step is important as a change of IP while working can prevent the nodes from communicating with each other.

The screenshot below shows a change in the status of my pods with this being the cause.

Using this command helped me to see the cause of this issue

sudo kubectl describe pod <pod_name>

4.2 Ensuring Network Connectivity

Verify that each Raspberry Pi can communicate with others in the network:

Ping Test:
- From one Raspberry Pi, ping another using their static IP addresses:
```
 ping 192.168.1.3
```

Replace the IP address with the actual address of the target Raspberry Pi.

SSH Connectivity:
- Ensure SSH connectivity between Raspberry Pis:
```
 ssh pi@192.168.1.3
```

Use the IP address of the target Raspberry Pi.

4.3 Troubleshooting Network Issues

If you encounter network issues, consider the following troubleshooting steps:

Check Configuration Files:
- Review the network configuration files on each Raspberry Pi.
Firewall Settings:
- Ensure that firewalls on Raspberry Pis are not blocking necessary ports.
Router Configuration:
- Check router settings to ensure it allows communication between devices.
Node Discovery:
- Verify that each node can discover others in the cluster.

With a well-configured network, your Kubernetes cluster is ready to conquer the world. In the next section, we'll explore persistent volume implementation.

5. Persistent Volume Implementation

To ensure data persistence and availability, we'll set up persistent volumes (PVs) in our Kubernetes cluster.

5.1 Creating Persistent Volumes

On the master node, create persistent volumes for data storage:

Create PV YAML File:

Create a YAML file (e.g., pv.yaml) with the PV configuration. Here's an example for a local storage PV:

 apiVersion: v1
 kind: PersistentVolume
 metadata:
   name: pv-local
 spec:
   capacity:
     storage: 1Gi
   accessModes:
     - ReadWriteOnce
   hostPath:
     path: "/mnt/data"

Apply the PV Configuration:
- Apply the configuration to create the PV:
```
 sudo k3s kubectl apply -f pv.yaml
```

5.2 Configuring Persistent Volume Claims

Now, let's configure persistent volume claims (PVCs) for your WordPress deployment:

Create PVC YAML File:

Create a YAML file (e.g., pvc.yaml) with the PVC configuration. Here's an example:

 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: pvc-local
 spec:
   accessModes:
     - ReadWriteOnce
   resources:
     requests:
       storage: 1Gi

Apply the PVC Configuration:
- Apply the configuration to create the PVC:
```
 sudo k3s kubectl apply -f pvc.yaml
```

5.3 Testing Persistent Volumes

Verify that persistent volumes are functioning as expected:

Check PV Status: -

Verify the status of the persistent volume:

 ```bash
 sudo k3s kubectl get pv
 ```

Ensure that the PV is in the 'Bound' state.

Check PVC Status:
- Verify the status of the persistent volume claim:
```
 sudo k3s kubectl get pvc
```

Ensure that the PVC is in the 'Bound' state.

Test Data Persistence:

Deploy a test pod that uses the persistent volume:

 apiVersion: v1
 kind: Pod
 metadata:
   name: test-pod
 spec:
   containers:
     - name: test-container
       image: busybox
       command: ["/bin/sh", "-c", "echo Hello Kubernetes! > /mnt/data/test-file && sleep 3600"]
       volumeMounts:
         - name: storage
           mountPath: "/mnt/data"
   volumes:
     - name: storage
       persistentVolumeClaim:
         claimName: pvc-local

Check if the test pod is running and verify the contents of the persistent volume.

With persistent volumes in place, your Kubernetes cluster is now equipped with reliable storage capabilities. The next step is to deploy WordPress on Kubernetes.

6. Deploying WordPress on Kubernetes

Let's dive into the exciting phase of deploying WordPress on your Kubernetes cluster.

6.1 Creating WordPress Deployment YAML

Create a YAML file (e.g., wordpress.yaml) to define the WordPress deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
        - name: wordpress
          image: wordpress:latest
          env:
            - name: WORDPRESS_DB_HOST
              value: mysql-service
            - name: WORDPRESS_DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: password
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: wordpress-service
spec:
  selector:
    app: wordpress
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: LoadBalancer

Apply the configuration to create the WordPress deployment:

sudo k3s kubectl apply -f wordpress.yaml

6.2 Configuring Service for WordPress

Expose the WordPress service to the external world:

Check Service Status:
- Verify that the WordPress service is running:
```
 sudo k3s kubectl get services
```

Note the external IP assigned to the service.

Access WordPress:
- Open a web browser and navigate to the external IP of the WordPress service.

Complete the WordPress installation steps.

6.3 Verifying WordPress Deployment

Confirm the successful deployment of WordPress:

Check Deployment Status:
- Verify the status of the WordPress deployment:
```
 sudo k3s kubectl get deployments
```

Ensure the desired number of replicas is running.

Verify Pods:
- Check the pods associated with the WordPress deployment:
```
 sudo k3s kubectl get pods
```

Ensure the pods are in the 'Running' state.

With WordPress up and running, it's time to explore how to scale your deployment for increased traffic.

7. Scaling the WordPress Deployment

Kubernetes makes scaling a breeze. Let's explore how to scale your WordPress deployment dynamically.

7.1 Horizontal Pod Autoscaling

Enable horizontal pod autoscaling for the WordPress deployment:

Create HPA YAML File:

Create a YAML file (e.g., hpa.yaml) for the horizontal pod autoscaler:

 apiVersion: autoscaling/v2beta2
 kind: HorizontalPodAutoscaler
 metadata:
   name: wordpress-hpa
 spec:
   scaleTargetRef:
     apiVersion: apps/v1
     kind: Deployment
     name: wordpress
   minReplicas: 1
   maxReplicas: 5
   metrics:
     - type: Resource
       resource:
         name: cpu
         targetAverageUtilization: 80

Apply the HPA Configuration:
- Apply the configuration to create the horizontal pod autoscaler:
```
 sudo k3s kubectl apply -f hpa.yaml
```

7.2 Testing Autoscaling

Simulate increased load on your WordPress site to trigger autoscaling:

Generate Load:
- Use a tool like Apache Benchmark to simulate increased traffic:
```
 ab -n 10000 -c 10 http://<wordpress-service-ip>/
```

Replace <wordpress-service-ip> with the IP of your WordPress service.

Monitor Autoscaling:
- Check the status of the horizontal pod autoscaler:
```
 sudo k3s kubectl get hpa
```

Monitor the number of replicas based on the defined metrics.

7.3 Analyzing Scalability

Review metrics and logs to analyze the scalability of your WordPress deployment:

Check Metrics:
- Examine the metrics gathered by the horizontal pod autoscaler:
```
 sudo k3s kubectl describe hpa wordpress-hpa
```
Review Logs:
- Analyze logs for individual pods to identify any performance issues:
```
 sudo k3s kubectl logs <pod-name>
```

Replace <pod-name> with the name of a WordPress pod.

With autoscaling in place, your WordPress deployment can dynamically adapt to varying workloads. Let's now focus on monitoring and observability.

8. Monitoring and Observability

A robust monitoring setup ensures that you stay informed about the health and performance of your Kubernetes cluster. Let's implement monitoring using Prometheus and visualize data with Grafana.

8.1 Implementing Prometheus for Monitoring

Deploy Prometheus to gather and store cluster metrics:

Create Prometheus YAML File:

Create a YAML file (e.g., prometheus.yaml) for Prometheus deployment:

 apiVersion: v1
 kind: Service
 metadata:
   name: prometheus-service
 spec:
   selector:
     app: prometheus
   ports:
     - protocol: TCP
       port: 9090
       targetPort: 9090
   type: LoadBalancer
 ---
 apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: prometheus
 spec:
   replicas: 1
   selector:
     matchLabels:
       app: prometheus
   template:
     metadata:
       labels:
         app: prometheus
     spec:
       containers:
         - name: prometheus
           image: prom/prometheus
           ports:
             - containerPort: 9090
           args:
             - "--config.file=/etc/prometheus/prometheus.yml"
           volumeMounts:
             - name: prometheus-config
               mountPath: /etc/prometheus
       volumes:
         - name: prometheus-config
           configMap:
             name: prometheus-config

Apply the Prometheus Configuration:
- Apply the configuration to create the Prometheus deployment:
```
 sudo k3s kubectl apply -f prometheus.yaml
```

8.2 Grafana Dashboard Configuration

Set up Grafana to visualize Prometheus metrics:

Create Grafana YAML File:

Create a YAML file (e.g., grafana.yaml) for Grafana deployment:

 apiVersion: v1
 kind: Service
 metadata:
   name: grafana-service
 spec:
   selector:
     app: grafana
   ports:
     - protocol: TCP
       port: 3000
       targetPort: 3000
   type: LoadBalancer
 ---
 apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: grafana
 spec:
   replicas: 1
   selector:
     matchLabels:
       app: grafana
   template:
     metadata:
       labels:
         app: grafana
     spec:
       containers:
         - name: grafana
           image: grafana/grafana
           ports:
             - containerPort: 3000
           env:
             - name: GF_SECURITY_ADMIN_PASSWORD
               value: "admin"
             - name: GF_SECURITY_ADMIN_USER
               value: "admin"
             - name: GF_SECURITY_ALLOW_EMBEDDING
               value: "true"

Apply the Grafana Configuration:
- Apply the configuration to create the Grafana deployment:
```
 sudo k3s kubectl apply -f grafana.yaml
```
Access Grafana:
- Access the Grafana dashboard using a web browser and the external IP of the Grafana service.
Configure Prometheus as a Data Source:
- Log in to Grafana (default credentials: admin/admin).
- Add Prometheus as a data source with the URL: http://prometheus-service:9090.
Import Kubernetes Dashboard:
- Import the official Kubernetes dashboard for Grafana.

With Prometheus and Grafana in place, your Kubernetes cluster is now equipped with powerful monitoring and visualization capabilities.

Conclusion

Congratulations on completing the implementation of a prototype Kubernetes-based cluster for scalable web-based WordPress deployment. This journey covered everything from setting up Raspberry Pis to deploying, scaling, and monitoring your WordPress application.

As you continue to explore the dynamic world of Kubernetes, remember that this guide serves as a solid foundation. Feel free to adapt and enhance your cluster based on evolving requirements. Embrace the scalability, flexibility, and resilience that Kubernetes brings to your web-based applications.

May your Kubernetes journey be filled with seamless deployments, effortless scalability, and a robust infrastructure that stands the test of time. Happy clustering!

Here are some resources I found helpful:
https://kubernetes.io/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/
https://docs.k3s.io/storage
YouTube playlist - https://youtube.com/playlist?list=PL9ti0-HuCzGbI4MdxgODTbuzEs0RS12c2&si=34d3StsvzwqnHc0j

How to Install VPN on Kali Linux Using OpenVPN and VPNBook

Chinaza Otumba — Thu, 22 Sep 2022 16:23:40 +0000

Kali Linux, formerly known as BackTrack, is synonymous with security and forensics. It is a Linux distro; based on Debian and built for cyber security experts, penetration testers, and white-hat hackers for digital forensics and penetration testing.

Having a VPN on your Kali Linux increases invisibility (private mode) while you keep testing for vulnerabilities.

In this article, we’ll show you how to install a VPN using OpenVPN and VPNBook on Kali Linux.

Why do you need a VPN on your Kali Linux?

Despite being built for digital forensics and penetration testing, Kali is just like every other Linux distro or operating system (OS), and as a user, you need to protect your activities while using it.

Failure to do so is like using an umbrella with holes,you'll definitely get soaked when it rains.

Installing a VPN helps cloak your IP address, bypass censorship/geographical limitations, and encrypt your network traffic. Or, in this case, you can view it as patching the umbrella.

Please note that despite doing all the things stated above, you may still need more than a VPN to protect yourself, depending on the task.

Why open-source VPN?

This article will focus on an open-source VPN, as they provide higher transparency compared to closed-source VPNs. Some closed-sourced VPNs even rely on open-source VPNs to function.

The selected VPN for today is OpenVPN because it is compatible with various OSes.

How to Install a VPN on Kali Linux?

Let's assume you already have Kali Linux up and running (either on your virtual machine or you dual boot it on your machine).

Next, open your terminal by navigating to your apps menu.
Then click the icon or use the command Ctrl + Alt + T.

Type the command Sudo apt-get install OpenVPN once the command line opens.



Sudo apt-get install OpenVPN

Depending on your setup, you might be asked to input your password.
To confirm a correct installation after the download,, type the command Openvpn into the terminal, “”.



Openvpn

Next, you'll need to get the required configuration files for your VPN to work properly. Open your browser and go to www.vpnhooks.com.

Then scroll down and select OpenVPN from the options available.

Select the server you prefer and download the configuration file.

For the purpose of this guide, we will be using US1 Server.

After downloading the configuration file, extract the files.

Configuring OpenVPN

There are two ways to proceed with the configuration from this point. It’s either through the GUI or the Terminal.

Configuring OpenVPN with GUI (Graphical User Interface)

Using the GUI option is typically easier, but the images provided could be slightly different on your version of Kali.

Go to settings and select network. Then click the plus sign(+) at the bottom

From the pop-up, select import saved VPN configuration

Input the username and password found on the VPNBook website and click Save.
After this, you're good to go!

Congratulations! You have successfully installed OpenVPN on your Kali Linux using the GUI method.

Configuring OpenVPN from the Terminal

Unlike the GUI method, the terminal stays the same on various Kali versions. Other Linux distros on the other hand would require different commands.

For this method, simply right-click on the folder where you have extracted the configuration files

And select open Terminal.
Then input the command, Sudo vpnbook-us2-tcp443.ovpn



Sudo vpnbook-us2-tcp443.ovpn

Input the username and password when prompted.

You've now successfully installed OpenVPN on your Kali Linux using the terminal.

Conclusion

We have successfully installed a VPN in our Kali through the GUI process and using the terminal.

If you made it to the end, congratulations.

DEV Community: Chinaza Otumba

How to Create Your First API with Python, Flask and Azure

Introduction

Understanding APIs

What is an API?

API architectural styles

Project Overview

Prerequisites

Step 1: Setting Up the Project

Step 2: Implementing the API

Step 3: Running the API Locally

Step 4: Deploying the API to Azure

Conclusion

Setting Up an NGINX Web Server on Azure: My DevOps HNG Stage 0 Experience

Introduction

Task Overview

Step-by-Step Approach

1️⃣ Setting Up the Ubuntu Server on Azure

2️⃣ Updating the System

3️⃣ Installing NGINX

4️⃣ Configuring the Custom Web Page

5️⃣ Configuring Inbound Port Rules on Azure

Using the Azure Portal:

6️⃣ Testing the Web Page

Challenges & Solutions

🔴 Challenge 1: Choosing the Right Server and Public IP Availability

🔴 Challenge 2: Configuring Inbound Ports on Azure

Key Takeaways

How This Task Helps My DevOps Journey

Conclusion

Beginners Guide to ReactJS — Data handling Using Props and State

Data Handling in React

What are Components?

Parent and Child

Functional Component

Hello, I love Mangos.

Class Component

Hello, I love Mangos.

What are Props?

Characteristics of Props:

“Props are Read-Only”

State

Hello, {this.state.name}

Hello, {this.state.name}

Quick Summary

Implementation of a Prototype Kubernetes-Based Cluster for Scalable Web-Based WordPress Deployment using K3s on Raspberry Pis

Setting the Stage: Objectives

Table of Contents

1. Setting Up Raspberry Pis

1.1 Hardware Preparation

1.2 Operating System Installation

1.3 Configuring Raspberry Pi Networking

1.4 Enabling SSH Access

2. Configuring the Master Node

2.1 Installing K3s on the Master Node

2.2 Configuring Master Node Components

3. Setting Up Worker Nodes

3.1 Installing K3s on Worker Nodes

3.2 Joining Worker Nodes to the Cluster

3.3 Verifying Worker Node Status

4. Network Configuration

4.1 Configuring Raspberry Pi Networking

4.2 Ensuring Network Connectivity

4.3 Troubleshooting Network Issues

5. Persistent Volume Implementation

5.1 Creating Persistent Volumes

5.2 Configuring Persistent Volume Claims

5.3 Testing Persistent Volumes

6. Deploying WordPress on Kubernetes

6.1 Creating WordPress Deployment YAML

6.2 Configuring Service for WordPress

6.3 Verifying WordPress Deployment

7. Scaling the WordPress Deployment

7.1 Horizontal Pod Autoscaling

7.2 Testing Autoscaling

7.3 Analyzing Scalability

8. Monitoring and Observability

8.1 Implementing Prometheus for Monitoring

8.2 Grafana Dashboard Configuration

Conclusion