This guide covers backup, restore, and migration of Kafka and ZooKeeper data.

Requirements

• Ubuntu 18.04 server (≥4GB RAM)
• Apache Kafka installed
• OpenJDK 8
• sudo user
• Optional: second server for migration

Step 1 — Prepare Data

Kafka stores data in:

• Topics → collections of messages
• Messages → basic data units

Create test topics/messages before backup.

Step 2 — Backup ZooKeeper Data

ZooKeeper stores:

• cluster state
• consumer data
• broker metadata

Backup ZooKeeper to preserve cluster consistency.

Step 3 — Backup Kafka Data

Export:

• topics
• messages

Use data dumps for full backup and recovery.

Step 4 — Restore ZooKeeper

Restore ZooKeeper state before Kafka to ensure cluster integrity.

Step 5 — Restore Kafka Data

Re-import:

• topics
• message data

This rebuilds the Kafka instance from backup.

Step 6 — Verify

Check:

• topics exist
• messages are readable
• consumers work correctly

Step 7 — Migrate to Another Server

• Transfer backup to new server
• Restore ZooKeeper
• Restore Kafka data

Used when:

• hardware failure
• infrastructure upgrade/downgrade

Summary

• Backup = Kafka data + ZooKeeper state
• Restore order matters (ZooKeeper → Kafka)
• Migration = restore on new server

Ensures data recovery and seamless infrastructure changes.

Full guide 👉https://vsys.host/how-to/how-to-back-up-import-and-migrate-your-apache-kafka-data-on-ubuntu-18-04

This setup deploys an NGINX proxy with configurable backend routing via Helm values.

Requirements

• Helm installed
• Running Kubernetes cluster (e.g., Minikube)

Start cluster if needed:

minikube start

Step 1 — Create Helm Chart

helm create nginx-proxy
cd nginx-proxy

Step 2 — Configure NGINX (ConfigMap)

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-config
data:
  nginx.conf: |
    server {
        listen 80;

        location / {
            proxy_pass $PROXY_URL;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    }

The proxy forwards requests to a backend defined by PROXY_URL.

Step 3 — Deployment

Key configuration:

env:
- name: PROXY_URL
  value: {{ .Values.proxyUrl | quote }}

The NGINX config is mounted to:

/etc/nginx/nginx.conf

Step 4 — Service (NodePort)

type: NodePort
nodePort: {{ .Values.nodePort }}

Step 5 — Values

proxyUrl: "http://default.proxy.url"
nodePort: 30000

Step 6 — Deploy

helm install my-nginx-proxy ./nginx-proxy \
--set proxyUrl="http://your.proxy.url" \
--set nodePort=32000

Check resources:

kubectl get deployments
kubectl get services

Step 7 — Access

minikube service my-nginx-proxy --url

Update / Remove

Update:

helm upgrade my-nginx-proxy ./nginx-proxy \
--set proxyUrl="http://new.proxy.url" \
--set nodePort=32001

Remove:

helm uninstall my-nginx-proxy

Summary

• ConfigMap → defines NGINX behavior
• Values → control backend and port
• Helm → manages deployment lifecycle

This allows changing proxy configuration without modifying Kubernetes manifests.

Full guide 👉 https://vsys.host/how-to/how-to-create-and-deploy-an-nginx-proxy-helm-chart-on-kubernetes

This guide outlines the common methods for installing .deb packages.

Using dpkg

The dpkg tool is the core package manager for Debian-based systems:

sudo dpkg -i package.deb

If dependencies are missing, fix them with:

sudo apt install -f

Using apt

You can install .deb files directly with apt, which also handles dependencies automatically:

sudo apt install ./package.deb

GUI Installation

Ubuntu also supports graphical installation. Simply double-click the .deb file and open it with the Software Center to install.

Summary

There are three main approaches:

• dpkg — manual installation
• apt — automatic dependency resolution
• GUI — user-friendly method

Each method fits different workflows, from scripting to desktop usage.

📘 Full guide:
https://vsys.host/how-to/how-to-install-deb-files-on-ubuntu

Common Restart Methods

1. Using reboot

The simplest and most common method:

sudo reboot

This command immediately restarts the system.

2. Using shutdown

To restart the system using shutdown:

sudo shutdown -r now

You can also schedule a restart by replacing now with a specific time (hh:mm).

3. Using systemctl

For systems running systemd:

sudo systemctl reboot

This command provides more control over system services.

4. Using init (Legacy)

Older systems using SysVinit can restart with:

sudo init 6

Runlevel 6 corresponds to a system reboot.

Remote Restart via SSH

You can restart a remote server by connecting via SSH:

ssh user@server_ip

Then execute any of the reboot commands.

Summary

Linux provides multiple ways to restart a system:

• reboot — simplest method
• shutdown -r — supports scheduling
• systemctl reboot — modern systemd approach
• init 6 — legacy method

Each method serves the same purpose, but the choice depends on your system and use case.

📘 Full guide:
https://vsys.host/how-to/how-to-restart-reboot-linux-server

Step 1: Check if wget is Installed

Run:

which wget

If no path is returned, wget is not installed.

You can also try:

wget

If the command is missing, the system will return an error.

Step 2: Install wget

For Debian-based systems:

sudo apt update
sudo apt install wget

For RHEL-based systems:

sudo dnf install wget -y

After installation, verify:

wget --version

Step 3: Fix PATH Issues

If wget is installed but still not found, it may not be in your PATH.

Add it manually:

export PATH=$PATH:/usr/local/bin

Then reload your shell:

source ~/.bashrc

Step 4: Troubleshooting

If installation fails:

• Check internet connection
• Update package repositories (apt update, dnf update)
• Ensure proper permissions
• Review terminal logs for errors

Summary

To fix the error:

• Install wget if missing
• Ensure it’s available in PATH
• Verify with wget --version

Once configured, wget can be used for file downloads, automation, and API interactions.

📘 Full guide:
https://vsys.host/how-to/how-to-fix-the-wget-command-not-found-error

Enabling firewalld

Start and enable firewalld to run on system boot:

systemctl enable firewalld
systemctl start firewalld

Check if the service is active:

firewall-cmd --state

Managing Services

To allow traffic for specific services like HTTP and HTTPS:

firewall-cmd --permanent --add-service=http
firewall-cmd --permanent --add-service=https

Apply the changes:

firewall-cmd --reload

Working with Ports

You can also open specific ports:

firewall-cmd --permanent --add-port=8080/tcp
firewall-cmd --reload

Zones

firewalld uses zones to define trust levels for network connections. You can assign interfaces and services to different zones depending on your security requirements.

Summary

firewalld provides:

• Dynamic rule updates without restart
• Service-based and port-based configuration
• Zone-based traffic control

This makes it a flexible tool for managing firewall rules on CentOS servers.

Full guide: 👉 https://vsys.host/how-to/how-to-enable-and-use-firewalld-on-centos-7

Using the touch Command

The fastest way to create a new empty file is with touch:

touch test.txt

If the file does not exist, it will be created. If it already exists, the command updates its timestamp.

Using the Redirect Operator

The > operator can create a file instantly:

> test2.txt

This command generates a new empty file in the current directory.

Creating Files with cat

The cat command can also create files and allow users to type content directly:

cat > test3.txt

After entering text, press Ctrl+D to save and exit.

Creating Files with echo

You can create a file and add content in a single command:

echo "Random sample text" > test4.txt

This writes the specified text into the file immediately.

Using printf for Formatted Output

For formatted text output, the printf command is useful:

printf "First line of text\nSecond line of text" > test5.txt

This allows more control over formatting and line breaks.

Summary

Linux offers several ways to create files quickly:

• touch – fastest method for empty files
• > – simple redirection creation
• cat – interactive file creation
• echo – create files with predefined text
• printf – formatted content output

Mastering these commands allows users to efficiently manage scripts, configuration files, and data directly from the command line.

Full tutorial:
https://vsys.host/how-to/how-to-create-a-file-in-linux

File Management Modules

Ansible provides several modules for working with files:

• file module — basic operations such as creating files, directories, or managing permissions
• copy module — copying files or embedding content directly into a file
• template module — creating files dynamically using variables and templates

Creating an Empty File

To ensure a file exists without modifying its contents:

- hosts: all
  tasks:
  - name: Creating an empty file
    file:
      path: "/your_path"
      state: touch

The state: touch parameter ensures the file exists while preserving idempotence.

Creating a File with Content

Use the copy module to generate a file and define its contents directly in the playbook:

- hosts: all
  tasks:
  - name: Creating a file with content
    copy:
      dest: "/your_path"
      content: |
        line 01
        line 02

This approach is useful for configuration files or scripts.

Creating Multiple Files

You can also create multiple files in one task using loops:

- hosts: all
  tasks:
  - name: Create multiple files
    file:
      path: "{{ item }}"
      state: touch
    loop:
      - test01.txt
      - test02.txt
      - test03.txt

Managing Permissions

Ansible can define ownership and permissions within the same task:

file:
  path: "/your_path"
  state: touch
  mode: "0755"
  owner: "test"

This ensures consistent configuration across all managed systems.

Full tutorial:
https://vsys.host/how-to/how-to-create-a-file-in-ansible

This guide explains how to install desktop environments on Ubuntu, Debian, and CentOS servers.

Prerequisites

Before installing a GUI, ensure you have:

• Root or sudo access
• SSH access to the server
• Internet connectivity for package downloads
• A remote access method such as VNC, KVM, or xRDP

Basic Preparation

Start by updating your system packages:

For Debian-based systems:

apt update && apt upgrade -y

For CentOS:

yum update -y

Create a separate user for GUI login:

useradd -m username && passwd username

Root logins are typically not allowed for graphical sessions.

Installing a Desktop Environment

Examples from the guide include installing:

• Ubuntu Desktop
• Kubuntu Desktop
• GNOME
• KDE

These environments provide full graphical access to the server.

Accessing the GUI

Once installed, the GUI can be accessed through:

• VNC — remote desktop access (not encrypted)
• KVM — direct console access through the hosting provider
• xRDP — encrypted remote desktop protocol access

For security, the guide recommends xRDP over VNC, since VNC connections are not encrypted.

Final Thoughts

Adding a GUI to a Linux server can simplify management for users who prefer graphical tools over the command line. With proper setup and secure remote access, it becomes easy to manage server resources visually.

Full tutorial:
https://vsys.host/how-to/how-to-installation-of-a-graphical-user-interface-for-linux

Step 1: Identify Your Disk

Use:

lsblk
sudo fdisk -l

to list all storage devices and their current partition layouts.

Step 2: Create or Modify Partitions

Start fdisk on your target disk:

sudo fdisk /dev/sdx

Within fdisk, use interactive commands to:

• Create (n)
• Delete (d)
• View current layout (p)
• Write changes (w) Replace /dev/sdx with your device name (e.g., /dev/sdb).

Step 3: Format Partitions

After creating partitions (e.g., /dev/sdx1), format with a filesystem like ext4:

sudo mkfs.ext4 /dev/sdx1

Other filesystems (XFS, Btrfs, etc.) can be used depending on your needs.

Step 4: Mount and Persist

Create a mount point and mount the partition:

sudo mkdir /mnt/data
sudo mount /dev/sdx1 /mnt/data

To keep it mounted after reboot, add an entry to /etc/fstab referencing the partition UUID.

Summary

Formatting disk partitions in Linux involves:

• Identifying the target device
• Creating or adjusting partitions
• Formatting them with appropriate file systems
• Mounting and configuring persistence

This workflow gives you full control over storage layout on servers or workstation environments.

Full step-by-step: https://vsys.host/how-to/how-to-format-disk-partitions-in-linux