Forem: Kevin Sheeran

Rust Series01 - Ownership is what you need to know

Kevin Sheeran — Sat, 10 Jan 2026 05:37:35 +0000

Hi fellows, since I've been using Rust for about 3 years now, I think it's time to share some experience to you guys, so I decide to post this Rust language learning series in next couple of weeks. Without further do, let's jump into it.

Assume you know some OOP(Oriented-Object-Programming) languages, like Java, C#. you will understand that everything is based on Object, but today you need to shift your mind as Rust is not an OOP language, instead it is all about ownership which means Rust will ask you explicitly who owns memory.

So Ownership answers one question:

Who is responsible for freeing this memory?

The core ownership rule (only one owner)

Every value in Rust has exactly ONE owner at any time

let s = String::from("hello");

•s owns the heap memory for "hello"
•When s goes out of scope → memory is freed automatically

Kubernetes Series(1): How to install Kubernetes in Ubuntu

Kevin Sheeran — Fri, 28 Apr 2023 04:00:40 +0000

Hi all, I recently learned some Docker key features and once in a while I come up with Kubernetes which really makes me wondering what is it and how does it work and what's the difference between Docker, so today I will guide you through clear the whole doubts.

What is Kubernetes?

Assuming you have learned Docker, if you don't know about Docker, it doesn't matter, I'll give you a example. Docker is like a container which put all of your stuff inside it, and in DevOps world, the stuff means your package applications and their dependencies, and you can run the container whatever you want in an isolated environment which make it easier to develop, test, and deploy applications across different environments. While Kubernetes is a platform for orchestrating and managing the containerized applications. It provides a higher-level abstraction that makes it easier to manage and scale containerized application in production.

How does it work?

As I mentioned above, Kubernetes is a powerful tool that automates the deployment, scaling, and management of containerized applications. So here is how it works:

The developer creates a containerized application using Docker, which packages the application and its dependencies into a portable container.
The developer defines the application's requirements, such as the number of replicas, resource requirements, and networking requirements, in a Kubernetes manifest file.
The Kubernetes master node receives the manifest file and uses it to create and manage the application's resources, such as pods, services, and replicasets.
Pods are the smallest deployable units in Kubernetes, and they contain one or more containers that share the same network namespace and can communicate with each other directly.
Services provide a stable IP address and DNS name for the pods, and they can load balance traffic to the pods based on labels.
Replicasets ensure that a specified number of replicas of a pod are running at all times, and they automatically scale up or down based on the application's resource requirements.
The Kubernetes master node monitors the state of the application's resources and automatically makes changes to ensure that the desired state is maintained.
If a pod fails or is terminated, the Kubernetes master node automatically replaces it with a new pod to maintain the desired number of replicas.
If the application's resource requirements change, such as increased traffic or resource-intensive tasks, Kubernetes can automatically scale up the number of replicas to meet the demand.
Kubernetes also provides advanced features such as rolling updates, which allow updates to be rolled out gradually to minimize downtime, and canary deployments, which allow new versions of the application to be tested on a small subset of users before being rolled out to everyone.

How to install it in Ubuntu?

Update your Ubuntu system using the following commands:

sudo apt-get update
sudo apt-get upgrade

Install Docker on your Ubuntu system by running the following commands:

sudo apt-get install docker.io
sudo systemctl start docker
sudo systemctl enable docker

Add the Kubernetes apt repository key by running the following command:

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

Add the Kubernetes apt repository to your system by running the following command:

sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

Update your system again using the following command:

sudo apt-get update

Install Kubernetes and its dependencies using the following command:

sudo apt-get install kubeadm kubelet kubectl

This will install Kubernetes, kubelet (the agent that runs on each node in the cluster), kubeadm (the tool used to bootstrap the cluster), and kubectl (the command-line tool used to interact with the cluster).

Initialize the Kubernetes cluster using kubeadm by running the following command:

sudo kubeadm init

This will create the Kubernetes control plane on your master node.

Once the initialization is complete, kubeadm will output a kubeadm join command. Copy this command to your clipboard, as you will need to run it on your worker nodes to join them to the cluster.
Configure your kubectl command-line tool to connect to the Kubernetes API server by running the following command:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

This will create a directory for your kubectl configuration and copy the configuration file from your master node to your local machine.

Deploy a pod network to the cluster using the following command:

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

This will deploy the Flannel pod network to the cluster, which will allow pods to communicate with each other across different nodes.

That's it! You now have a Kubernetes cluster running on your Ubuntu system. You can add worker nodes to the cluster by running the kubeadm join command on each worker node, and you can deploy applications to the cluster using kubectl.

Docker Series: Run Grafana + Prometheus with Docker Compose in Ubuntu

Kevin Sheeran — Thu, 27 Apr 2023 09:59:20 +0000

Hi, there! Since docker has become more and more popular in CI/CD world, today I will be using a brief hands-on experience on how to run Grafana and Prometheus with Docker Compose in Ubuntu system

Install Docker on your Ubuntu machine. You can do this by following the official Docker installation guide for Ubuntu: https://docs.docker.com/engine/install/ubuntu/
Create a new directory for your Prometheus and Grafana configuration files:

mkdir ~/monitoring
cd ~/monitoring

Create a new Docker Compose file:

nano docker-compose.yml

Paste the following configuration into the file:

version: '3'

services:
  prometheus:
    image: prom/prometheus
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - --config.file=/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    networks:
      - monitoring

  grafana:
    image: grafana/grafana
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - "3000:3000"
    networks:
      - monitoring

volumes:
  grafana_data:

networks:
  monitoring:

Save and close the file
Create a new Prometheus configuration file:

nano prometheus.yml

Paste the following configuration into the file:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:9090']

Save and close the faile.
Start the Docker containers:

docker-compose up -d

Wait for a few seconds for the containers to start up, then navigate to http://localhost:3000/ in your web browser to access Grafana.
Log in to Grafana using the default credentials (username: admin, password: admin), then add a new data source by clicking on the "Add data source" button and selecting "Prometheus" as the data source type.
Configure the Prometheus data source by specifying the URL as http://prometheus:9090/ and clicking on the "Save & Test" button.

You can now create dashboards in Grafana and start monitoring your applications with Prometheus.

That's it! You now have a working setup of Grafana and Prometheus running with Docker on Ubuntu