DEV Community: shravan jain

Monitoring a Server with Prometheus and Grafana: A Beginner’s Guide

shravan jain — Fri, 23 May 2025 08:52:46 +0000

Monitoring a website is super important for developers. It helps you figure out what’s causing issues like why your website is down, why requests are taking too long, or what might be slowing things down in general.

That’s where Prometheus and Grafana come in.

Prometheus is used to collect metrics from endpoints that you define (like your server or apps).
Grafana takes those metrics from Prometheus and turns them into easy-to-understand graphs and dashboards, so you can actually see what’s going on behind the scenes.

What This Guide Covers and Prerequisites

This guide is intended for beginners who want to learn the basics of setting up Prometheus and Grafana for monitoring their website.
I'll cover how to write a YAML configuration file for the Prometheus server, how to containerize it using Docker, and how to pull the Grafana image and use its dashboard.
Prerequisites

Basic knowledge of Linux/command line

Docker (for containerization)

Basic understanding of YAML

Familiarity with any backend language (I'm using Flask in this guide)

Setting Up Prometheus

Creating an flask server

from flask import Flask
from prometheus_flask_exporter import PrometheusMetrics

app = Flask(__name__)
metrics=PrometheusMetrics(app)
@app.route('/')
def test():
    return "hello world"

if __name__ == '__main__':
    app.run(host='0.0.0.0',debug=True)

In the above program, I have created a PrometheusMetrics instance and passed the app object as an argument.
This automatically sets up an endpoint (/metrics) that exposes application metrics, which Prometheus can scrape.

Now, if you open the website and go to endpoint /metrics you would now see this.

if you find any problem or get error 404 turn off the debug mode or run export DEBUG_METRICS=1 then run the application.

prometheus server
- Create a prometheus-config.yml to put the prometheus configuration.

 global:
  scrape_interval: 4s # it'll scrape the metrics from the end point every 4s

scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ["<you-target-address>"] # put you private address here to make that as your end-point

creating a docker container for prometheus server

version: "3"

services:
  prom-server:
    image: prom/prometheus
    ports:
      - 9090:9090
    volumes:
      - ./prometheus-config.yml:/etc/prometheus/prometheus.yml

This container pulls the prom/prometheus image and listens on port 9090 on my machine (host), forwarding it to port 9090 inside the container. It uses Docker volumes to bind ./prometheus-config.yml (on the host) to /etc/prometheus/prometheus.yml (inside the container), so any changes made to the config file on the host will be reflected in the container at runtime.

Summary of Prometheus Setup

I created a Flask app and used PrometheusMetrics to integrate Prometheus with it by passing the Flask app instance. This setup automatically exposed a /metrics endpoint, where all the raw data is available. Then, I used a Prometheus Docker container and specified a prometheus.yml file inside it to define which address to scrape the metrics from. Now, Prometheus collects the metrics from my Flask app and stores the data so it can be used for monitoring and visualization.

Setting Up Grafana

Setting up Grafana is simple — just run it in a Docker container:
docker run -d -p 3000:3000 --name=grafana grafana/grafana-oss
There are two versions of Grafana:

Grafana OSS (Open Source Software) — free and open to use (this is the one we’re using)

Grafana Enterprise — has extra features for businesses

After running the container, open your browser and go to:
http://localhost:3000
You’ll see the Grafana login page. Use the default credentials:

Username: admin

Password: admin

Grafana will ask you to set a new password — choose anything you like.
Connect Grafana to Prometheus

Once you’re logged in:

Click on “Add your first data source”

Choose Prometheus

In the URL box, enter the address of your Prometheus server, for example:

For example, if your Prometheus server is running at 172.20.54.207 on port 5000, enter:
http://172.20.54.207:5000

Scroll down and click “Save & Test”
You should see a green success message that says Grafana is connected to Prometheus.

That’s it — you're all set!

Here's what the raw metrics look like in Prometheus. Grafana takes this data and turns it into easy-to-understand visual dashboards.

Write Less, Reuse More: Template Inheritance in Flask Explained

shravan jain — Sat, 17 May 2025 07:57:15 +0000

This turned out to be a pretty cool concept. While working on my site monitoring app, I had around three or four services like uptime checks, DNS lookups, pinging, and a few others. Since I’m not much of a UI designer, I ended up creating separate files for each service, even though they all shared the same layout.

That’s when I discovered Flask’s template inheritance. Instead of repeating the same code over and over, you can create a base layout and reuse it wherever you want. It really helped clean things up and made everything way easier to manage. Here’s how you can set it up.

Inheriting from base to child:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>template-inheritance</title>
</head>
<body>
    <header>
        <nav>
            <ul>
                <a href="home">home</a>
                <a href="about">about</a>
                <a href="contact">contact</a>
            </ul>
        </nav>
    </header>
    <main>
        {% block content %}{% endblock %}
    </main>
    <footer>
        &copy; 2025 My Site
    </footer>
</body>
</html>

Simply put, if you want to use the same template like reusing the same navigation bar across multiple pages, you can just extend the base file. The whole layout gets reused automatically.

And if you want to change something specific on a page, you define blocks in the base file that let you override those sections whenever you need to. For example, if you want to override content inside the tag, you would define a block like this in the base:

 <main>
      {% block content %}{% endblock %}
 </main>

Then, in your child template, you extend the base and override that block:

{% extends "base.html" %}

{% block content %}
<div class="content">
    hello world!!
</div>
{% endblock %}

That way, you get the shared layout and can customize parts of the page without repeating your code.

Mastering Flask Blueprints: The First Step to Scalable Web Apps

shravan jain — Thu, 15 May 2025 16:08:37 +0000

As I started learning Flask, I was building simple apps just to understand the basics and get comfortable with it. Once I felt a bit more confident, I decided to start a project, a site monitoring tool. Since I knew the project would grow and include more functionality, I realized that things should be organized better. That’s when I came across Flask Blueprints. A Blueprint is a modular way to organize code and routes into separate components. Today, I set up my first Blueprint in Flask and here’s how it went.

Project structure

blueprint-example/
├── run.py
└── app/
    └── routes.py
    └── __init__.py
    └── templates/
        └── index.html

Step 1: Creating a simple Blueprint

from flask import Blueprint,render_template
#creating a flask blueprint called 'main_route'
main_route=Blueprint('main_route',__name__)
#define a route on this blueprint
@main_route.route('/')
def blue_example():
    return render_template('index.html')

Step 2: Register the blueprint

from flask import Flask

app=Flask(__name__)

def blue_example():
    from .routes import main_route
    app.register_blueprint(main_route)#registering my blueprint to my flask app instance
    return app

Step 3: Run the app

from app import blue_example

app=blue_example()#Calling a function to get flask app instance

if __name__ == '__main__':
    app.run(debug=True) #run the app in debug mode

What i found use full?

I basically had an idea of how this works because I had learned about MVC (Model, View, and Controller) in Java. The working process of both is quite similar, so I was able to grasp it a bit quicker.

Here are a few things I found helpful about using Blueprints:

It's a clean way to split the code logically. For example, separating routes and the dashboard into components makes the structure much easier to work with.
It's much easier to manage as the app grows and more features are added.
It makes the project more organized and scalable, which is especially useful when working in teams or revisiting the project later.

My Journey into Python and DevOps Begins

shravan jain — Wed, 14 May 2025 14:46:38 +0000

Hey everyone! 👋

I'm Shravan Jain, a student who recently found a niche in coding.

I’ve always been fascinated by the terminal. That childhood excitement of using a black screen with white text never really left me. Over time, I started exploring fun and nerdy things—like configuring servers in Cisco Packet Tracer and tweaking Firefox CSS just to see what I could do.

For a while, I was doing these small, non-productive (but oddly satisfying) things that sparked my curiosity. But now, I’ve decided to channel that curiosity into something more focused and practical.

I’ve started learning Python scripting to automate tasks and understand how things work behind the scenes. I'm drawn to Python because of how versatile it is—it's like a multitool for developers. Whether it's scripting, automation, DevOps, or backend systems, Python is everywhere.

This is my first step into something more structured and skill-driven, and I'm excited to share what I learn along the way!

Thanks for reading, and feel free to connect if you're also on a similar journey. 🙌

Python #DevOps #StudentDev #LearningJourney #Automation