DEV Community: qudus olamide

Kubernetes ConfigMap: What It Is and Why You Need It

qudus olamide — Fri, 03 Jan 2025 21:39:24 +0000

Managing configuration effectively is crucial for building scalable and maintainable Kubernetes applications. Enter ConfigMaps—a Kubernetes-native way to handle configuration seamlessly. But why does Kubernetes call it ConfigMap, and why should you use it? Let’s dive in!

Why Kubernetes Calls It ConfigMap

Kubernetes calls it a ConfigMap because its purpose is to map configuration data into your application in a flexible and dynamic way. The name emphasizes its function: managing configuration separately from application code.

The Need for ConfigMaps

Storing environment variables directly in files or hardcoding them in your app can be inflexible and is not considered a good practice.

Here’s why ConfigMaps are better:

Separation of Concerns

Without ConfigMap: Hardcoding environment variables in files or application code means any changes require modifying and redeploying your application.

With ConfigMap: Decouples configuration from code and deployment manifests. You can update the configuration without redeploying the app.

Centralized Configuration Management

Manage configuration data for multiple applications or services in one place.

Avoid scattering environment variables across multiple files.

Dynamic Updates

With ConfigMap: Update the configuration dynamically if your app supports it.

Without ConfigMap: Manually edit and redeploy the app to apply changes.

Kubernetes-Native Integration

ConfigMaps integrate seamlessly with Kubernetes resources like Pods and Deployments, making them ideal for managing app settings in Kubernetes.

Flexible Usage

ConfigMaps can be used in multiple ways:

As environment variables.

Mounted as configuration files inside containers.

Accessed directly by applications.

Practical Example

Here’s how you can use a ConfigMap in Kubernetes:

Define a ConfigMap:

apiVersion: v1
kind: ConfigMap
metadata:
name: app-config
data:
DATABASE_HOST: db-service
LOG_LEVEL: debug

Reference the ConfigMap in a Deployment:

env:

name: DATABASE_HOST valueFrom: configMapKeyRef: name: app-config key: DATABASE_HOST
name: LOG_LEVEL valueFrom: configMapKeyRef: name: app-config key: LOG_LEVEL

Update the ConfigMap

Modify the ConfigMap without changing the deployment to update configurations dynamically.

Limitations of ConfigMaps

While ConfigMaps offer significant benefits, they have some limitations:

No Versioning or Change Tracking:

ConfigMaps do not inherently track changes or versions.

Workaround: Use tools like Git or Helm to manage ConfigMap changes.

Not Suitable for Sensitive Data:

ConfigMaps are not encrypted at rest.

Workaround: Use Kubernetes Secrets for sensitive data.

Limited Dynamic Capabilities:

Cannot generate dynamic values or perform templating like Jinja templates.

Workaround: Use Helm or Kustomize for dynamic configuration.

Data Size Limitations:

ConfigMaps have a 1 MB size limit.

Workaround: Break large configurations into multiple ConfigMaps or use mounted volumes.

Namespace-Scoped:

ConfigMaps are tied to a single namespace.

Workaround: Duplicate ConfigMaps across namespaces or use cluster-wide tools.

Key Takeaway

While environment variables in files may suffice for small setups, ConfigMaps provide better flexibility, scalability, and maintainability for managing configurations in Kubernetes. They align with the best practice of separating configuration from code and deployments.

Call to Action

How do you use ConfigMaps in your Kubernetes setup? Do you have any tips or unique use cases? Share your thoughts in the comments below!

Architecture of Kubernetes

qudus olamide — Sat, 14 Dec 2024 12:24:07 +0000

Kubernetes, also known as k8s, is an open-source container orchestration platform that manages Docker containers in the form of a cluster. The Kubernetes architecture consists of a master node (control plane) and multiple worker nodes (data plane).

Control Plane Components

API Server: The core component of Kubernetes that resides on the master node. Acts as the gateway between the Kubernetes cluster and the external world, exposing Kubernetes functionalities through RESTful APIs. Handles requests for operations such as deploying applications, scaling workloads, or retrieving cluster information.
Scheduler: Responsible for scheduling pods or resources to worker nodes. Uses information from the API server to decide which node is best suited for a given workload, taking factors like resource availability and constraints into account.
Controller Manager: Ensures that the desired state of the cluster, as defined in configurations (e.g., YAML files), is maintained. Manages tasks such as maintaining replicas of pods (via ReplicaSets), handling node failures, and ensuring persistent storage is bound to the correct pods.
etcd: A distributed key-value store that serves as Kubernetes' database. Stores all cluster data, including configurations and the current state of the cluster. Acts as a backup and ensures consistency across the cluster.
Cloud Controller Manager: An optional component used for integrating Kubernetes with cloud providers. Manages cloud-specific services such as load balancers, storage provisioning, and network routes.

Data Plane Components

Kubelet: A Kubernetes agent running on each worker node. Responsible for pod lifecycle management and ensuring the containers in a pod are running as expected.
Container Runtime: Enables containers to run on a node. Examples include Docker, containerd, and CRI-O.
Kube-proxy: A network proxy that manages networking rules on worker nodes. Assigns IP addresses to pods and handles load balancing for services within the cluster.

Real-World Example
Imagine an e-commerce platform like Amazon that handles millions of users daily. Kubernetes can be used to:
• Deploy microservices for user authentication, product catalogs, and payment systems.
• Scale workloads automatically during peak shopping seasons.
• Ensure high availability by replicating critical services across multiple worker nodes.
• Handle rolling updates and rollbacks seamlessly for new features or fixes.
Diagram
Below is a simplified representation of the Kubernetes architecture:

Additional Notes
• Pods are the smallest deployable units in Kubernetes and represent a single instance of a running process in a cluster. A pod can contain one or more containers.
• The control plane ensures that the cluster operates as intended, while the data plane performs the actual work of running containers and providing networking.
Kubernetes’ architecture enables it to manage complex containerized applications with high availability, scalability, and resilience.

Step-by-Step Setup: MySQL Database Server on AWS EC2

qudus olamide — Sun, 29 Sep 2024 23:58:29 +0000

When setting up a MySQL database on an EC2 instance using Ubuntu as your AMI (Amazon Machine Image), it's essential to grasp some key concepts first:

Key Concepts:

Database: A collection of organized information, made up of database
objects.

Database Object: Fundamental components that help organize, control, and access data effectively. Examples include tables, queries, forms, reports, etc.

Database Management System (DBMS): Software used to manage databases. Examples include MySQL, MongoDB, PostgreSQL, Oracle, and Microsoft SQL.

Relational Database: A database where data is stored in tables, with relationships between tables based on shared data.

Relational Database Management System (RDBMS): Software that maintains relational databases. Examples include MySQL, PostgreSQL, Microsoft SQL, and Oracle.

Database interaction occurs through web applications or directly through SQL commands.

The four core database operations (CRUD) are:
C - Create
R – Read

U - Update
D - Delete

Setting Up a MySQL Database Server on EC2:

Now that we understand these key concepts, let's walk through the steps to set up MySQL on an EC2 instance:

Launch the EC2 Instance
Start by launching your EC2 instance and selecting Ubuntu as your AMI. Once the instance is running, update the operating system by executing:
$ sudo apt update -y
Install MySQL Server
Install MySQL by running the following command:
$ sudo apt install mysql-server -y
Verify Installation
Confirm that MySQL is installed by checking the version:
$ mysql –version or locate the installation: $ which mysql
Check MySQL Status
Ensure that the MySQL service is running with this command
$ sudo systemctl status mysql

Securing MySQL:

After installing MySQL, the next best practice is to secure the installation. This involves setting a root password, removing anonymous users, and disabling remote root login. Run the secure installation script:
$ sudo mysql_secure_installation

This script will guide you through the following steps:
Setting a root password
Removing anonymous users
Disallowing root login remotely
Removing the test database
Once secured, you’re ready to start using MySQL.

Interacting with MySQL:

MySQL uses Structured Query Language (SQL) to manage data. To interact with the MySQL server, enter the MySQL shell:
$ sudo mysql

Within the MySQL shell (denoted by mysql>), here are a few useful commands:
mysql> SHOW DATABASES;
mysql> USE mysql;
mysql> SHOW TABLES;
_
Creating a Database and Table:
Let's now create a database and a table inside the MySQL server.

Create a Database To create a new database, use the CREATE DATABASE SQL command. For example, mysql> CREATE DATABASE schoolDB;

Create a Table To create a table in a database use the SQL command: CREATE TABLE table_name ( column1 datatype, column2 datatype, column3 datatype, .... ); For example, we create a table named subject in the schoolDB database: mysql> CREATE TABLE subject ( ID int, First_name varchar(10), Last_name varchar(10) );

View Tables After creating the table, view the list of tables: mysql> SHOW TABLES;

Inserting and Retrieving Data:

Insert Data into the Table Use the INSERT INTO statement to add records. INSERT INTO table_name (column1, column2, column3, ...) VALUES (value1, value2, value3, ...); Here's an example:

mysql> INSERT INTO subject (ID, First_name, Last_name)
VALUES (1, 'Qudus', 'Dosunmu');

Retrieve Data To view the records you’ve inserted, use the SELECT statement: mysql> SELECT * FROM subject;

NOTE:

MySQL is not case-sensitive, so commands can be entered in uppercase or lowercase.
Always end SQL commands with a semicolon (;).

Conclusion
With this step-by-step guide, you can now deploy and interact with a MySQL database on an EC2 instance. If you're looking to expand your knowledge or troubleshoot, feel free to reach out or share your experiences!

Sources & Credits:
W3school
Fredrick Achiever
Skill Afrika Cloud Computing Bootcamp For Beginners