Coder Legion - Recent posts tagged apache

Kafka in hospitals: real-world event architecture for HIS, LIS and billing in a Venezuelan mid-size

Wed, 29 Jul 2026 06:37:11 +0000

Most Kafka “healthcare interoperability” examples are theoretical or focused on US/EU EHRs. I wanted to share a concrete case from a mid‑size hospital in Venezuela where we used Kafka as the event backbone between HIS, LIS and billing systems.

Context:

4–8 systems needed to know the same things in near real time: admissions, lab results, charges.

Point‑to‑point integrations had become a mess: custom scripts, duplicate records, fragile error handling.

The hospital knew it would keep adding systems (BI, SAP, new clinical modules) over the next few years.

What we ended up doing:

Defined topics by clinical domain (admissions, lab-results, orders, billing-events) instead of “one topic for everything”.

Partitioned by patient or encounter ID to preserve clinical event order per case.

Used replication factor 3 and min.insync.replicas=2 because losing a lab result is not just a business data issue.

Enabled idempotent + transactional producers (exactly-once semantics) for lab results and financial events, where duplicates are harmful.

The article goes into more detail on:

How we mapped HL7/FHIR messages to Kafka topics.

Trade‑offs in infra cost vs. resilience for a hospital context.

When Kafka was clearly the wrong tool (small clinics with only 2–3 systems and low event volume).

Link (in Spanish, but I’m happy to summarize or answer questions in English here):

Kafka in hospitals

Running Lightweight Services on Raspberry Pi: Build Powerful Mini Servers at Home

Tue, 10 Mar 2026 13:20:18 +0000

The Raspberry Pi has come a long way from being just a learning tool for beginners. Today, it’s powerful enough to run real services that developers, hobbyists, and DevOps engineers use every day.

From hosting internal dashboards to running automation tools, the Raspberry Pi is perfect for lightweight services that don’t require heavy infrastructure. With proper setup, this small single board computer can operate as a reliable mini server for development, monitoring, and home automation.

In this guide, we’ll explore how to run lightweight services on Raspberry Pi, the types of applications that work best, and best practices for keeping your Pi fast, stable, and secure.

Why Use a Raspberry Pi for Lightweight Services?

Running services locally on a Raspberry Pi offers several advantages.

First, it’s extremely cost effective. Instead of paying for a cloud server every month, a Raspberry Pi can run continuously with minimal electricity usage.

Second, it provides full control of your environment. You can experiment, break things, and rebuild without affecting production systems.

Third, it’s perfect for learning DevOps and system administration skills. Managing services on a Raspberry Pi exposes you to Linux networking, containerization, monitoring, and automation.

Many developers also use the Raspberry Pi as a personal infrastructure lab where they test tools before deploying them to cloud servers.

What Counts as a Lightweight Service?

A lightweight service is an application that requires minimal CPU, RAM, and disk resources. These services usually run quietly in the background and handle specific tasks.

Examples include:

Monitoring tools
Web dashboards
Local APIs
Home automation systems
DNS or ad blocking services
IoT gateways
Small databases

The Raspberry Pi is ideal for these because they don't require heavy processing power.

Choosing the Right Raspberry Pi Setup

Before running services, make sure your Raspberry Pi is properly configured.

Recommended Hardware

For best results, use:

Raspberry Pi 4 (4GB or 8GB RAM)
Fast microSD card (Class 10 or better)
Reliable power supply
Optional SSD for better performance

A stable storage device is especially important because microSD cards can degrade with heavy read/write operations.

Operating System

Most developers use Raspberry Pi OS Lite for server environments. It’s lightweight, fast, and avoids unnecessary desktop components.

Once installed, update the system:

sudo apt update && sudo apt upgrade

Keeping your system updated ensures stability and security.

Lightweight Services You Can Run on Raspberry Pi

Let’s explore some practical services developers commonly run on a Raspberry Pi.

1. Local Web Server

Running a small web server is one of the most common uses.

You can install Nginx or Apache and host:

personal dashboards
development APIs
internal tools

Example installation:

sudo apt install nginx

Once running, your Raspberry Pi becomes a small but capable web server for local applications.

2. Monitoring and Metrics

Monitoring tools help you track system performance across your network.

Popular lightweight options include:

Prometheus Node Exporter
Grafana dashboards
Uptime monitoring tools

Running these locally allows you to monitor:

server uptime
CPU and memory usage
network activity

It’s a great way to learn observability practices used in production environments.

3. Home Automation Services

The Raspberry Pi is widely used for home automation platforms.

Tools like Home Assistant allow you to connect and control:

smart lights
thermostats
cameras
sensors

Because these services are event driven rather than compute heavy, they perform very well on Raspberry Pi hardware.

4. Local API Services

Developers often run small APIs for testing or internal tools.

For example, you could host:

a Node.js API
a Python Flask service
a Laravel backend

These APIs can be used for:

automation workflows
IoT device communication
experimental projects

Your Raspberry Pi essentially becomes a small development server.

5. Network Utilities

The Raspberry Pi can also act as a network utility server.

Common examples include:

Pi hole for network wide ad blocking
local DNS servers
VPN gateways
SSH jump hosts

These services require very little processing power but provide significant value in a home or lab environment.

Using Docker to Manage Raspberry Pi Services

One of the best ways to run multiple services is by using Docker containers.

Docker allows you to isolate applications, manage dependencies, and deploy services quickly.

Install Docker with:

curl -sSL https://get.docker.com | sh

Once installed, you can run services like this:

docker run -d -p 3000:3000 my-service

Using Docker on Raspberry Pi also prepares you for modern DevOps workflows used in production environments.

Performance Tips for Running Services on Raspberry Pi

Although the Raspberry Pi is powerful for its size, optimizing performance is important.

Use Lightweight Applications

Avoid heavy services that require large databases or significant processing.

Monitor Resource Usage

Tools like htop help you track CPU and memory usage in real time.

htop

Reduce Background Processes

Running fewer unnecessary services keeps the system responsive.

Use SSD Storage (If Possible)

An external SSD significantly improves read/write performance compared to microSD cards.

Security Best Practices

Any device running services should follow basic security principles.

Some simple steps include:

Change the default password
Disable unused ports
Use SSH keys instead of passwords
Enable automatic updates
Install a firewall such as ufw

Example firewall setup:

sudo apt install ufw
sudo ufw allow ssh
sudo ufw enable

These small changes greatly improve security.

Why Developers Love Raspberry Pi Home Labs

Many engineers build entire home lab environments using Raspberry Pi devices.

These labs allow developers to:

test deployment pipelines
experiment with Kubernetes or Docker
simulate distributed systems
learn networking and automation

It’s a practical way to gain real infrastructure experience without expensive cloud costs.

Final Thoughts: Small Device, Big Possibilities

The Raspberry Pi proves that powerful infrastructure doesn’t always require large servers or expensive cloud environments.

With the right setup, this tiny computer can run reliable lightweight services for development, monitoring, automation, and learning.

Whether you're building a personal DevOps lab, hosting internal tools, or experimenting with IoT projects, the Raspberry Pi provides a flexible platform to explore and innovate.

If you haven’t tried running services on one yet, now is the perfect time to start. You might be surprised how much you can accomplish with such a small device.

If you found this guide useful, share it with fellow developers or anyone exploring Raspberry Pi projects. More practical tutorials and DevOps insights are coming soon.

Securing Your VPS: Basic Firewall, SSH, and SSL Setup Guide

Sat, 07 Jun 2025 17:01:23 +0000

A Simple Guide to Make Your VPS Safer — Even If You're Just Starting Out

Your VPS (Virtual Private Server) is like your home on the internet — and just like a home, it needs locks, fences, and security cameras to stay safe. This guide will walk you through three critical steps to secure your VPS:

Set up a basic firewall
Secure -SSH access
Install SSL for HTTPS

Step 1: Set Up a Basic Firewall with UFW (Uncomplicated Firewall)

A firewall controls what kind of traffic can reach your VPS. Let’s use UFW, a beginner-friendly firewall for Ubuntu/Debian systems.

✅ Install UFW

sudo apt update
sudo apt install ufw

✅ Allow SSH (so you don’t lock yourself out)

sudo ufw allow OpenSSH

If you're using a non-standard SSH port (e.g., 2222), allow that too:

sudo ufw allow 2222/tcp

✅ Allow HTTP and HTTPS

sudo ufw allow 80
sudo ufw allow 443

✅ Enable the Firewall

sudo ufw enable

To check status:

sudo ufw status

Pro Tip: Only open ports that your app or server needs!

Step 2: Secure SSH Access

SSH is how you remotely access your server. But by default, it’s a bit too open.

✅ Change the Default SSH Port (optional but adds extra protection)

Edit the SSH config file:

sudo nano /etc/ssh/sshd_config

Find and change:

Port 22

To something like:

Port 2222

Then restart SSH:

sudo systemctl restart ssh

Still in /etc/ssh/sshd_config, find:

PermitRootLogin yes

Change to:

PermitRootLogin no

Restart SSH again:

sudo systemctl restart ssh

✅ Use SSH Keys Instead of Passwords

From your local machine, run:

ssh-keygen -t rsa -b 4096

Then copy the key to your VPS:

ssh-copy-id username@your-server-ip

Disable password authentication (optional but recommended):

sudo nano /etc/ssh/sshd_config

Set:

PasswordAuthentication no

Restart SSH:

sudo systemctl restart ssh

Step 3: Install Free SSL Using Let’s Encrypt (with Certbot)

SSL (HTTPS) encrypts your website traffic. Let’s Encrypt makes it easy and free.

✅ Install Certbot

For Nginx:

sudo apt install certbot python3-certbot-nginx

For Apache:

sudo apt install certbot python3-certbot-apache

✅ Issue an SSL Certificate

sudo certbot --nginx

Or for Apache:

sudo certbot --apache

Follow the prompt and choose to redirect HTTP to HTTPS.

✅ Auto-Renew SSL

Let’s Encrypt certificates expire every 90 days. Set up auto-renewal:

sudo systemctl list-timers

Certbot typically installs a timer, but you can test renewal with:

sudo certbot renew --dry-run

Final Thoughts

Security doesn't have to be scary.

With just a few commands, you've:

✅ Protected your SSH login
✅ Closed unnecessary network doors
✅ Encrypted web traffic with HTTPS

These are must-do steps for anyone hosting websites, APIs, or apps on a VPS — even beginners.

Bonus Tools for Extra Security (Optional)

Fail2Ban: Automatically blocks brute-force attempts
ModSecurity: Web application firewall
Auditd: For logging and monitoring server changes

Resources

Understanding Linux Package Manager: Deploying A Lamp Stack in Linux.

Sun, 30 Mar 2025 08:31:27 +0000

A package manager in Linux is a command-line or graphical tool that automates the process of installing, updating, configuring, and removing software packages. It simplifies software management by handling dependencies, repositories, and system consistency.

Key Functions of a Package Manager:

Installation: Downloads and installs software packages from a repository.
Upgrades: Updates software packages to the latest versions.
Removal: Removes software packages from the system.
Dependency Management: Automatically resolves and installs any required dependencies for a package.
Package Integrity: Verifies the authenticity and integrity of packages.
Repository Management: Allows users to add or remove software repositories.

Why are Package Managers Important?

Simplified Software Management:
They automate the process of installing, updating, and removing software, making it easier for users to manage their systems.
Dependency Resolution:
They automatically handle dependencies, ensuring that all required packages are installed, which prevents "dependency hell".
Security and Integrity:
They help ensure that software packages are authentic and haven't been tampered with.
Centralized Repositories:
They allow users to access a centralized repository of software packages, making it easier to find and install software.

Example Workflow (Ubuntu):

Without wasting much time, let us begin by downloading Ubuntu's package manager. To do this, you need to download Ubuntu Multipass. After downloading and installing it successful , here is how it will look once you open the Multipass;

You will need to download an Ubuntu image.After the downloaded the image, open the instance on the left hand pane of the multipass app. Click on new terminal.

Once you open the shell a welcome note will appear, to clear that welcome note you will need to run the command "clear"

To install anything in Ubuntu, you need to be on admin mode. The command for that is "Sudo Su". Now if you do not want to be on admin mode (root mode)but still want to perform an installation, lets say you want to install NGINX, "Sudo apt install nginx"

NOTE:

Provided you're not in root mode, you will need to add "Sudo" to every command. Sudo gives you that administrative privilege.

DEPLOYING A LAMP STACK

The LAMP stack is a robust, open-source software suite used to build and host dynamic websites and web applications. A LAMP stack is a popular open-source software bundle used for building and hosting web applications. The acronym "LAMP" stands for the four core components: Linux, Apache, MySQL and PHP.

Here's a breakdown of each component:

Linux:
The open-source operating system that serves as the foundation for the LAMP stack, providing a stable and secure environment for running web applications.
Apache:
A widely used web server software that handles HTTP requests and delivers web content to users.
MySQL:
A relational database management system used for storing and managing data for web applications.
PHP:
A server-side scripting language used to create dynamic web content, interacting with MySQL to fetch and display data.

Step-by-Step Deployment

Step 1: System Update
To do this, run the command "sudo apt update && sudo apt upgrade -y"

Step 2: Install Apache Web Server
To install apache2, run the command "sudo apt install apache2 -y"

Step 3: Enable and start the service
Run the command "sudo systemctl enable apache2 --now"

To know if Apache2 is installed, run the command "ip addr show."

Copy the IP address and paste on a browser.

Step 4: Install MySQL Database
Run the command "sudo apt install mysql-server -y"

Step 5: Secure MySQL
Run the command "sudo mysql_secure_installation"

Step 6: Install PHP
Run the command "sudo apt install php libapache2-mod-php php-mysql php-cli php-curl php-json -y"

Step 7: Test PHP Configuration
Run the command echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

Visit: http:// your IP address/info.php to view the PHP details page.

Step 8: Remove the test file afterward
Run the command sudo rm /var/www/html/info.php

Step 9: Security Best Practices

Configure Firewall
Allow only necessary traffic:

Allow HTTP/HTTPS
Run the command sudo ufw allow 'Apache Full'
Allow SSH
Run the cammand "sudo ufw allow ssh"
Activate firewall
Run the command "sudo ufw enable"

We have successfully deployed a LAMP Stack on Linux for hosting dynamic websites and web applications. That wasn't difficult.

Setup a LAMP Server on a VPS in Under an Hour: The Ultimate Guide to Web Hosting

Wed, 19 Feb 2025 14:48:22 +0000

In today’s digital age, having a reliable web hosting solution is paramount. A Virtual Private Server (VPS) offers a balance of affordability, performance, and full control over your server environment. This guide will walk you through setting up a robust LAMP (Linux, Apache, MariaDB, PHP) stack on your VPS using an automated Bash script—all in under an hour.

For the complete installation script and further details, please visit our GitHub repository: https://github.com/giftbalogun/vpsLAMPsetup.

Why Choose a VPS for Web Hosting?

A VPS offers dedicated resources and increased flexibility compared to shared hosting. This means better performance, enhanced security, and complete control over the software and configurations installed on your server. Whether you’re hosting a personal blog or a complex web application, a VPS is an excellent choice.

Understanding the LAMP Stack

The LAMP stack is a proven combination of technologies that work together to create a powerful web hosting environment:

Linux - The operating system that serves as the foundation.
Apache - A popular and reliable web server for handling HTTP requests.
MariaDB - A robust database management system (a fork of MySQL) used to store and manage data.
PHP - A server-side scripting language that enables dynamic web content.

Step-by-Step Setup Guide

1. Updating the System

Before installing any packages, it’s important to update your system to ensure all repositories and packages are current. This minimizes conflicts and security vulnerabilities.

sudo apt update -y
sudo apt upgrade -y

The setup script automatically performs these steps. In case of an error, the script is designed to cancel the installation gracefully.

2. Installing Apache Web Server

Apache is the core component of our LAMP stack. The script installs Apache, starts the service immediately, and enables it to run on boot, ensuring your web server is always operational.

sudo apt install apache2 -y
sudo systemctl start apache2
sudo systemctl enable apache2

These commands ensure that Apache is installed correctly and persists across reboots.

3. Installing PHP and Essential Extensions

PHP powers dynamic web content. The script installs PHP along with a suite of extensions needed to support various functionalities such as database connectivity, JSON processing, and more.

sudo apt install php libapache2-mod-php php-cli php-common php-redis php-mysql php-cgi php-curl php-json php-mbstring php-xml php-zip php-pdo php-phar php-iconv -y

Each extension is chosen to provide comprehensive support for modern web applications.

4. Installing MariaDB

MariaDB serves as our database system. It’s known for its speed and reliability, making it a great alternative to MySQL. The script installs MariaDB, starts it, and configures it to launch on startup.

sudo apt install mariadb-server -y
sudo systemctl start mariadb
sudo systemctl enable mariadb

5. Securing Your Database

Security is critical when managing databases. The script runs mysql_secure_installation to help you set a root password, remove anonymous users, and disable remote root logins. This hardening process is essential to protect your data.

sudo mysql_secure_installation

6. Installing phpMyAdmin

phpMyAdmin provides a web-based interface for managing your MariaDB databases. The script installs phpMyAdmin and creates a symbolic link in Apache’s root directory, making it easily accessible through your browser.

sudo apt install phpmyadmin -y
sudo ln -s /usr/share/phpmyadmin /var/www/html/phpmyadmin

After installation, you can access phpMyAdmin at http://your-server-ip/phpmyadmin.

7. Restarting Apache

To apply all configuration changes and updates, the script restarts Apache. This ensures that all new installations and settings take effect immediately.

sudo systemctl restart apache2

8. Installing Composer

Composer is a dependency manager for PHP that simplifies the management of libraries and packages. The script downloads Composer and moves it to a system-wide accessible location.

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer
composer --version

This ensures that Composer is installed correctly and can be used for managing your PHP project dependencies.

The Complete Automated Installation Script

The following Bash script encapsulates all the steps mentioned above. It includes error handling to ensure that if any step fails, the installation process is halted and the system remains in a stable state.



#!/bin/bash

# Function to handle cancellation
cancel_installation() {
  echo -e "\nInstallation canceled by the user. Cleaning up..."
  exit 1
}

# Set trap for SIGINT (Ctrl+C)
trap cancel_installation SIGINT

# Update package list
echo "Updating package list..."
sudo apt update -y || cancel_installation
sudo apt upgrade -y || cancel_installation

# Install Apache
echo "Installing Apache..."
if ! sudo apt install apache2 -y; then
  echo "Failed to install Apache. Exiting..."
  exit 1
fi
sudo systemctl start apache2 || cancel_installation
sudo systemctl enable apache2 || cancel_installation

# Install PHP and necessary extensions
echo "Installing PHP and required extensions..."
if ! sudo apt install php libapache2-mod-php php-cli php-common php-redis php-mysql php-cgi php-curl php-json php-mbstring php-xml php-zip php-pdo php-phar php-iconv -y; then
  echo "Failed to install PHP. Exiting..."
  exit 1
fi

# Install MariaDB
echo "Installing MariaDB..."
if ! sudo apt install mariadb-server -y; then
  echo "Failed to install MariaDB. Exiting..."
  exit 1
fi
sudo systemctl start mariadb || cancel_installation
sudo systemctl enable mariadb || cancel_installation

# Secure MariaDB installation
echo "Securing MariaDB..."
sudo mysql_secure_installation || cancel_installation

# Install phpMyAdmin
echo "Installing phpMyAdmin..."
if ! sudo apt install phpmyadmin -y; then
  echo "Failed to install phpMyAdmin. Exiting..."
  exit 1
fi

# Enable phpMyAdmin in Apache
echo "Enabling phpMyAdmin in Apache..."
sudo ln -s /usr/share/phpmyadmin /var/www/html/phpmyadmin || cancel_installation

# Restart Apache
echo "Restarting Apache..."
sudo systemctl restart apache2 || cancel_installation

# Install Composer
echo "Installing Composer..."
if ! curl -sS https://getcomposer.org/installer | php; then
  echo "Failed to download Composer. Exiting..."
  exit 1
fi
sudo mv composer.phar /usr/local/bin/composer
composer --version || cancel_installation

# Final Summary
echo "Installation complete!"
echo "---------------------------------------------------------"
echo "Apache is installed and running."
echo "PHP and necessary extensions are installed."
echo "MariaDB is installed and running."
echo "phpMyAdmin is accessible at http://$(hostname -I | awk '{print $1}')/phpmyadmin"
echo "Composer is installed and ready to use."
echo "---------------------------------------------------------"

This script ensures that each step is executed correctly, and that the system is left in a stable state even if errors occur. By automating the installation process, you can deploy a fully functional LAMP server quickly and with confidence.

Wrapping Up

With your LAMP server now set up on your VPS, you have a robust environment ready for hosting websites, web applications, or even development projects. The flexibility of a VPS combined with the reliability of the LAMP stack makes this an ideal solution for many use cases.

Remember to keep your server updated and secure by routinely applying patches and monitoring its performance. With tools like phpMyAdmin and Composer at your disposal, managing your server and deploying applications becomes a streamlined process.

Conclusion

This guide has walked you through setting up a LAMP server on a VPS in under an hour. The key takeaways include:

Using a VPS for greater control, performance, and security.
The benefits of the LAMP stack for robust web hosting.
Automating server setup with a comprehensive Bash script.
Ensuring secure database management and easy PHP dependency management with Composer.

For the full installation script and more details, be sure to visit our GitHub repository: https://github.com/giftbalogun/vpsLAMPsetup.

Happy Hosting!