DEV Community: Isaac Ntumpi

Your Linux Server (Debian), But Make It Clickable: Setting Up Cockpit for Web-Based Administration

Isaac Ntumpi — Mon, 19 May 2025 07:09:13 +0000

From the CLI to the Cloud Control Room

It was 3 AM, and I was knee-deep in systemctl logs, SSH’d into a remote server, eyes half-closed, trying to restart a frozen service. The commands were familiar, but the fatigue was real. That's when I thought: “Why can't Linux server management feel a little more... visual?”

Not because I don't love the terminal — I do.
But because sometimes, the right interface can speed up your workflow, reduce errors, and make monitoring services actually enjoyable.

That’s when I met Cockpit — the open-source web GUI for Linux administration.

This guide walks you through installing and using Cockpit on your Linux server, transforming it into a beautiful, browser-accessible control room. You’ll still have your CLI power — but now with dashboards, charts, toggles, and peace of mind.

What is Cockpit?
Cockpit is a lightweight, real-time, web-based interface that lets you:

Monitor system performance
Manage services, users, and storage
Update software packages
Access a web-based terminal
Manage containers and virtual machines (with plugins)

It’s fast, secure, and already included in the official repos of many distributions.

[Step 1: Update Your Server & Install Cockpit]

Before installing any new package, it's good practice to ensure the system is up to date.

sudo apt update && sudo apt upgrade -y

This command updates the package lists and upgrades all installed packages to their latest versions.

Cockpit is available in Ubuntu's official repositories, so installation is simple:

sudo apt install cockpit -y

This installs the core Cockpit interface. Depending on your use case, you may add modules later.

[Step 2: Start and Enable Cockpit]

Cockpit uses systemd and comes with a socket-activated service. Enable and start it:

sudo systemctl enable --now cockpit.socket

To confirm Cockpit is up and listening:

sudo systemctl status cockpit.socket

Look for Active: active (listening) and port 9090.

[Step 3: Access the Web Interface & Login to Cockpit]

Now, open your browser and navigate to:

https://:9090
For example: 10.10.0.5

⚠️ Don’t worry if you see a self-signed certificate warning. Accept it for now or configure HTTPS properly with Let's Encrypt for production environments.

Use your Linux system credentials (e.g., the same user you SSH with).
If you are using a non-root user, make sure it has sudo privileges.

Once logged in, you’ll see a dashboard with real-time stats, system health, storage, networking, logs, and a built-in terminal.

[Step 4: Extend Cockpit with Additional Features]

Want more than just basic monitoring? Cockpit supports modules:

sudo apt install cockpit-pcp cockpit-networkmanager cockpit-packagekit

cockpit-pcp for performance metrics
cockpit-networkmanager for managing networking
cockpit-packagekit for software updates via GUI

Conclusion

Cockpit transforms Linux administration from purely command-line to an experience that is clean, visual, and efficient. It empowers you to:

Respond faster to system issues

Gain visibility into system health

Onboard junior admins with ease

Whether you're managing a home lab, a VPS, or a fleet of servers, Cockpit is a tool worth having.

You’re still the sysadmin. Just now with a dashboard.

From Zero to Git Hero: Hosting Your Own GitHub with Gitea on Linux

Isaac Ntumpi — Sun, 18 May 2025 22:09:15 +0000

The Dev Who Refused to Be Held Hostage

It always starts the same.
You’re building something great—maybe a side project, maybe your startup’s backend. You push your first commit, create a beautiful README, and start dreaming big.

Then reality hits.

Suddenly, you're being nudged toward premium pricing tiers, facing storage limits, or worrying about whether your private repo is actually private. And deep down, something tells you: I should own this.

That was me. And if you're reading this, maybe that's you too.

What if I told you that you could host your own lightweight, blazing-fast GitHub alternative… entirely for free… on your own server?

In this guide, I'll walk you through installing Gitea, a modern and minimal Git service platform, on your own Linux box. You’ll never look at GitHub the same way again.

Let’s take the power back.

What is Gitea?

Gitea is an open source, self-hosted Git service. Think GitHub, but:

Lightweight
Super fast
Written in Go
Easy to install and maintain
Friendly for solo developers and teams Perfect if you want control, privacy, and zero dependency on third-party platforms.

Prerequisites

A Linux-based server (tested on Ubuntu 22.04)
Root or sudo privileges
Git installed
A domain name (optional, but recommended)

[Step 1: Install Required Packages & Create a Dedicated Gitea User]

- Required Packages installation

sudo apt update && sudo apt upgrade -y
sudo apt install git wget curl unzip -y

- Dedicated Gitea User creation

sudo adduser \
  --system \
  --shell /bin/bash \
  --gecos 'Git Version Control' \
  --group \
  --disabled-password \
  --home /home/git \
  git

[Step 2: Download Gitea Binary & Create Necessary Directories]

*- Gitea Binary downloading *
Visit https://dl.gitea.io/gitea to get the latest version. Then:

wget -O gitea https://dl.gitea.io/gitea/1.21.11/gitea-1.21.11-linux-amd64
chmod +x gitea
sudo mv gitea /usr/local/bin/

Note: Replace the version as needed based on the latest release.

- Necessary Directories creation

sudo mkdir -p /var/lib/gitea/{custom,data,log}
sudo chown -R git:git /var/lib/gitea/
sudo chmod -R 750 /var/lib/gitea/

sudo mkdir /etc/gitea
sudo chown root:git /etc/gitea
sudo chmod 770 /etc/gitea

[Step 3: Create a Gitea Systemd Service File]

sudo nano /etc/systemd/system/gitea.service

Paste the following content:

[Unit]
Description=Gitea (Git with a cup of tea)
After=network.target

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/gitea/
ExecStart=/usr/local/bin/gitea web --config /etc/gitea/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea

[Install]
WantedBy=multi-user.target

Then reload and start:

sudo systemctl daemon-reexec
sudo systemctl daemon-reload
sudo systemctl enable --now gitea

[Step 4: Access the Web Interface]

Visit:
http://:3000
eg. 192.168.1.123
You'll land on the installation page. Fill in:

Database: SQLite (for testing) or PostgreSQL/MySQL (for production)
Repository Root Path: /var/lib/gitea/data/git/repositories
Run User: git
Domain: Your server’s IP or domain
SSH Port: 22
HTTP Port: 3000

Once configured, click Install Gitea.

Boom 💥 — Your own GitHub is live

Conclusion

By hosting Gitea on your own server, you’re not just setting up another tool —
you’re reclaiming your autonomy.

You now:

Own your codebase
Control user access
Avoid vendor lock-in
Spend $0 while scaling

It’s a small step for your terminal, but a giant leap for your developer independence.

And hey — if you're building a team, a startup, or just want to sharpen your DevOps edge, there's nothing more powerful than owning the pipeline from git init to production.

Set It and Forget It: Automate Daily EC2 Lifecycle with Python Like a Pro

Isaac Ntumpi — Sun, 18 May 2025 21:15:01 +0000

A Cloud Engineer's Midnight Regret

It’s 00:12 AM.
You’re brushing your teeth, mentally preparing for tomorrow’s stand-up, when it hits you like a thunderbolt:

“Wait… did I forget to shut down the EC2 instances?”

You sprint back to your laptop, heart racing, praying your cloud bill isn’t already ballooning past reason.
The AWS Console loads… slowly.
You sigh in frustration.
Another night, another bill for machines you weren’t using.

If this scene feels familiar, you’re not alone. Many engineers — from solo devs to seasoned sysadmins — struggle to manage cloud resources with surgical precision, especially when those resources are needed only part of the day.

The good news?
There’s a fix — and it’s beautifully simple.

In this article, you’ll build a smart, Python-powered automation that shuts down all your EC2 instances at midnight and wakes them up at 5 AM — every day — without fail.
We’ll walk through the process step by step, with logs you can watch live and full control over your infrastructure. No serverless complexity, no expensive automation platforms.

Just you, Python, and a little crontab magic.
Let’s automate like professionals.

Prerequisites

Make sure you have the following ready:

An AWS account with programmatic access (Access Key & Secret)
A Linux environment (local machine, EC2 instance, or WSL on Windows)
Python 3 installed
boto3 and awscli installed

[Step 1: Install Required Tools]

Install the AWS SDK for Python:

pip install boto3

Configure your AWS credentials:

aws configure

You'll be prompted to enter:

Your Access Key ID
Your Secret Access Key
Default AWS region (e.g. us-east-1)
Default output format (e.g. json) This generates the necessary configuration under ~/.aws/credentials.

[Step 2: Write the Python Scripts]

We'll create two Python scripts:

stop_ec2.py → to stop instances at 00:00
start_ec2.py → to start instances at 05:00

Let’s get started.

stop_ec2.py

mkdir ~/ec2_scheduler
cd ~/ec2_scheduler
nano stop_ec2.py

Paste the following code:

#!/usr/bin/env python3
import boto3

def stop_all_instances():
    ec2 = boto3.client('ec2')
    response = ec2.describe_instances(Filters=[{
        'Name': 'instance-state-name',
        'Values': ['running']
    }])

    instances_to_stop = []
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            instances_to_stop.append(instance['InstanceId'])

    if instances_to_stop:
        print("Stopping instances:", instances_to_stop)
        ec2.stop_instances(InstanceIds=instances_to_stop)
    else:
        print("No running instances found.")

if __name__ == "__main__":
    stop_all_instances()

Make it executable:

chmod +x stop_ec2.py

start_ec2.py
Now let’s create the startup script:

nano start_ec2.py

Paste this:

#!/usr/bin/env python3
import boto3

def start_all_instances():
    ec2 = boto3.client('ec2')
    response = ec2.describe_instances(Filters=[{
        'Name': 'instance-state-name',
        'Values': ['stopped']
    }])

    instances_to_start = []
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            instances_to_start.append(instance['InstanceId'])

    if instances_to_start:
        print("Starting instances:", instances_to_start)
        ec2.start_instances(InstanceIds=instances_to_start)
    else:
        print("No stopped instances found.")

if __name__ == "__main__":
    start_all_instances()

And make it executable too:

chmod +x start_ec2.py

[Step 3: Schedule Scripts Using crontab]

Open the crontab editor:

crontab -e

Add the following lines at the bottom:

0 0 * * * /usr/bin/python3 /home/isaac/ec2_scheduler/stop_ec2.py >> /home/your_user/ec2_scheduler/stop.log 2>&1
0 5 * * * /usr/bin/python3 /home/isaac/ec2_scheduler/start_ec2.py >> /home/your_user/ec2_scheduler/start.log 2>&1

Replace /home/isaac/ with your actual username or full path.

You can verify your crontab jobs were added:

crontab -l

[Step 4: Monitor with tail -f]

To watch logs in real time:

tail -f ~/ec2_scheduler/stop.log
# or
tail -f ~/ec2_scheduler/start.log

You'll see output like:

Stopping instances: ['i-01abcd2345efgh678']

No stopped instances found.

IAM Policy Required

Your IAM user or role should have the following minimum permissions:
It's a json file

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ec2:DescribeInstances",
        "ec2:StartInstances",
        "ec2:StopInstances"
      ],
      "Resource": "*"
    }
  ]
}

Manual Testing (Optional)

You can manually trigger the scripts to test them before relying on the cron jobs:

python3 stop_ec2.py
python3 start_ec2.py

Then check the logs with:

tail ~/ec2_scheduler/stop.log
tail ~/ec2_scheduler/start.log

Conclusion

In this tutorial, we’ve built a clean, reliable automation to manage AWS EC2 instances using nothing but Python and Linux’s built-in cron scheduler. This setup is especially helpful for dev/test environments, overnight cost reduction, or any non-production workloads that don’t need to be running 24/7.

By combining boto3, crontab, and log monitoring with tail -f, you've gained fine-grained control over your cloud environment — no expensive scheduler tools, no overengineering. Just simple, effective DevOps.

Take it further by filtering EC2 instances by tags, regions, or instance types, or by sending email alerts on failures.

Automation isn't just about convenience — it's about discipline, consistency, and clarity in your operations.

Hello World Every Minute: Crontab + Live Log Tailing

Isaac Ntumpi — Thu, 15 May 2025 08:12:50 +0000

When managing Linux systems, automating repetitive tasks is key to efficiency and consistency. With crontab, you can schedule scripts to run at any interval — including every minute. In this short guide, we’ll create a script that simply prints HELLO WORLD, schedule it to run every minute, and log its output. You'll also learn how to monitor it live using tail -f, a powerful command-line tool for real-time log viewing.

[Step 1: Create the Python File]

Open a terminal and create the script file:

nano ~/hello.py

Paste the following code:

#!/usr/bin/env python3
from datetime import datetime

logfile = "/home/$USER/hello.log"  # Replace $USER manually if needed

with open(logfile, "a") as f:
    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    f.write(f"[{now}] HELLO WORLD\n")

print("HELLO WORLD")

Tip: Replace "/home/$USER/hello.log" with your actual path, for example: "/home/isaac/hello.log"

Then make the file executable:

chmod +x ~/hello.py  #bash

[Step 2: Add the script to crontab and Test and monitor logs live]

Open your user’s crontab:

crontab -e

Add this line at the bottom:

* * * * * /usr/bin/python3 /home/your_user/hello.py

After a minute, check if the log file was created:

ls -l ~/hello.log

Then, use tail -f to monitor the log in real-time:

tail -f ~/hello.log

You should see a new "HELLO WORLD" line appear every minute. Like on below image.

Conclusion

By following this step-by-step guide, you've learned how to schedule a simple Python script to run every minute using crontab. This script prints and logs a message, giving you a hands-on understanding of how cron jobs, logging, and real-time monitoring with tail -f work together in a Linux environment.

Even though this example is simple—just printing "HELLO WORLD"—the approach is powerful and scalable. You can adapt this pattern to automate tasks like data collection, backups, notifications, or system health checks.

Whether you're a beginner exploring automation or a developer integrating scripts into a production pipeline, mastering cron and logging is a foundational skill. Keep experimenting, build smarter scripts, and level up your DevOps toolbox!