DEV Community: Ronal Daniel LUPACA MAMANI

# 🔍 Observability with Prometheus in PHP

Ronal Daniel LUPACA MAMANI — Sat, 05 Jul 2025 15:15:31 +0000

Observability is a key property of modern systems that allows understanding what is happening inside an application by collecting signals such as metrics, logs, and traces. Unlike simple monitoring (which only detects symptoms), observability lets us diagnose root causes.

In distributed environments, having observability tools is essential for detecting bottlenecks, performance drops, hidden errors, and unexpected behaviors. One of the most popular and accessible solutions is Prometheus, an open-source metrics collector originally created by SoundCloud, which allows querying data in real-time using its own query language: PromQL.

In this article, I will show you how to implement a complete observability flow in PHP, using only Prometheus.

🎯 What will you learn?

What observability is and why it matters
How to generate custom metrics using PHP
How to configure Prometheus to collect them
How to visualize metrics directly in Prometheus dashboard

🧰 Tools used

Tool	Purpose
PHP (CLI)	Metric simulation and exposure
Prometheus	Metric collection and querying
Windows	Local development environment

🧪 Step 1: Generate metrics from PHP

We create two PHP files: one to simulate metrics and another to expose them for Prometheus.

📄 `generator.php`

<?php
$counter = 0;

while (true) {
    $start = microtime(true);
    sleep(rand(1, 3));

    $counter++;
    $duration = microtime(true) - $start;

    file_put_contents("metrics.txt", 
        "# HELP uploads_total Total uploads
" .
        "# TYPE uploads_total counter
" .
        "uploads_total {$counter}
" .
        "# HELP upload_processing_seconds Processing time
" .
        "# TYPE upload_processing_seconds gauge
" .
        "upload_processing_seconds {$duration}
"
    );

    sleep(1);
}

📄 `metrics.php`

<?php
header('Content-Type: text/plain');
readfile("metrics.txt");

▶️ Step 2: Run the scripts

Open a terminal and run the generator:

php generator.php

In another terminal, start the PHP server:

php -S localhost:8000 metrics.php

Verify everything works by visiting: 👉 http://localhost:8000

⚙️ Step 3: Configure Prometheus

Download Prometheus from: https://prometheus.io/download
Extract the ZIP and create prometheus.yml:

global:
  scrape_interval: 5s

scrape_configs:
  - job_name: 'php_metrics'
    static_configs:
      - targets: ['localhost:8000']

  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

▶️ Step 4: Run Prometheus

In PowerShell or CMD, run:

.\prometheus.exe --config.file=prometheus.yml

Open: 👉 http://localhost:9090

📈 Step 5: Query metrics in Prometheus

In the dashboard, go to “Status → Targets” and check if it's UP
In the “Graph” tab, run:

uploads_total

then:

upload_processing_seconds

Press Execute to see the PHP-generated metrics.

📊 1. `upload_processing_seconds`

upload_processing_seconds{instance="localhost:8000", job="php_metrics"} 3.0004351139069

Description:
This metric shows the time it took to process a file upload in PHP. In this example, it took about 3 seconds.

Labels:

instance="localhost:8000": Source endpoint (metrics.php on port 8000)
job="php_metrics": Job name defined in prometheus.yml

📦 2. `uploads_total`

uploads_total{instance="localhost:8000", job="php_metrics"} 1

Description:
This metric is a counter of how many times the upload process ran. In this case, it only ran once.

Labels:

instance="localhost:8000": Metric source endpoint.
job="php_metrics": Registered job for that metric.

📦 GitHub Repository

https://github.com/daniellupaca/php_Prometheus-/tree/main

🧠 Conclusion

Prometheus allows you to instrument any modern app without much complexity. By integrating real-time metrics from PHP, you get an accessible solution for academic projects, performance testing, or production systems without needing external tools like Grafana.

This approach can easily be extended to Node.js, Python, Java, etc.

❤️ Was this useful?

If you liked this article, share it or comment your experience using Prometheus and PHP.

# 🛰️ Observabilidad en PHP con Prometheus

Ronal Daniel LUPACA MAMANI — Sat, 05 Jul 2025 15:13:42 +0000

La observabilidad es una propiedad clave de los sistemas modernos que permite comprender lo que ocurre dentro de una aplicación mediante la recopilación de señales como métricas, logs y trazas. A diferencia del simple monitoreo (que solo detecta síntomas), la observabilidad nos permite diagnosticar las causas raíz de los problemas.

En entornos distribuidos, contar con herramientas de observabilidad es esencial para detectar cuellos de botella, caídas de rendimiento, errores ocultos y comportamientos inesperados. Una de las soluciones más populares y accesibles es Prometheus, un recolector de métricas de código abierto creado originalmente por SoundCloud, que permite consultar datos en tiempo real mediante su propio lenguaje de consultas: PromQL.

En este artículo te muestro cómo implementar un flujo completo de observabilidad en PHP, utilizando únicamente Prometheus.

🎯 ¿Qué aprenderás?

Qué es la observabilidad y por qué importa
Cómo generar métricas personalizadas con PHP
Cómo configurar Prometheus para recolectarlas
Cómo visualizar las métricas directamente en el dashboard de Prometheus

🧰 Herramientas utilizadas

Herramienta	Propósito
PHP (CLI)	Simulación y exposición de métricas
Prometheus	Recolección y consulta de métricas
Windows	Entorno local de desarrollo

🧪 Paso 1: Generar métricas desde PHP

Creamos dos archivos PHP: uno que genera las métricas simuladas y otro que las expone para ser recolectadas por Prometheus.

📄 `generador.php`

<?php
$conteo = 0;

while (true) {
    $inicio = microtime(true);
    sleep(rand(1, 3));

    $conteo++;
    $tiempo = microtime(true) - $inicio;

    file_put_contents("metricas.txt", 
        "# HELP uploads_total Total de subidas\n" .
        "# TYPE uploads_total counter\n" .
        "uploads_total {$conteo}\n" .
        "# HELP upload_processing_seconds Tiempo de procesamiento\n" .
        "# TYPE upload_processing_seconds gauge\n" .
        "upload_processing_seconds {$tiempo}\n"
    );

    sleep(1);
}

📄 `metrics.php`

<?php
header('Content-Type: text/plain');
readfile("metricas.txt");

▶️ Paso 2: Ejecutar los scripts

Abre una terminal y ejecuta el generador:

php generador.php

En otra terminal, ejecuta el servidor PHP:

php -S localhost:8000 metrics.php

Verifica que todo funcione abriendo: 👉 http://localhost:8000

⚙️ Paso 3: Configurar Prometheus

Descarga Prometheus desde: https://prometheus.io/download
Extrae el ZIP y coloca este archivo como prometheus.yml:

global:
  scrape_interval: 5s

scrape_configs:
  - job_name: 'php_metrics'
    static_configs:
      - targets: ['localhost:8000']

  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

▶️ Paso 4: Ejecutar Prometheus

Desde PowerShell o CMD, ejecuta:

.\prometheus.exe --config.file=prometheus.yml

Abre: 👉 http://localhost:9090

📈 Paso 5: Consultar métricas en Prometheus

En el panel, ve a “Status → Targets” y asegúrate que esté UP
En la pestaña “Graph”, escribe:

uploads_total

y luego:

upload_processing_seconds

Presiona Execute y verás las métricas generadas por PHP.

📊 1. `upload_processing_seconds`

upload_processing_seconds{instance="localhost:8000", job="php_metrics"} 3.0004351139069

Descripción:
Esta métrica representa el tiempo que tomó procesar una subida de archivo en la aplicación PHP. En este caso, tomó aproximadamente 3 segundos.

Etiquetas asociadas:

instance="localhost:8000": Indica que la métrica proviene del endpoint que corre en el puerto 8000 (donde está expuesto metrics.php).
job="php_metrics": Nombre del trabajo configurado en prometheus.yml.

📦 2. `uploads_total`

uploads_total{instance="localhost:8000", job="php_metrics"} 1

Descripción:
Esta métrica es un contador de cuántas veces se ha ejecutado el proceso de subida. En este ejemplo, solo se ha registrado una subida.

Etiquetas asociadas:

instance="localhost:8000": Fuente del endpoint de métricas.
job="php_metrics": Trabajo registrado para esa métrica.

📦 Repositorio de código

https://github.com/tuusuario/observabilidad-php-prometheus (reemplaza con tu enlace real)

🧠 Conclusión

Prometheus permite instrumentar cualquier aplicación moderna sin mucha complejidad. Al integrar métricas en tiempo real desde PHP, conseguimos una solución accesible para proyectos académicos, pruebas de rendimiento o sistemas reales sin necesidad de herramientas externas como Grafana.

Este enfoque puede extenderse fácilmente a Node.js, Python, Java, etc.

❤️ ¿Te fue útil?

Si te gustó este artículo, compártelo o comenta tu experiencia con Prometheus y PHP.

Enterprise Design Pattern: Implementing the Service Layer Pattern in Python

Ronal Daniel LUPACA MAMANI — Thu, 01 May 2025 21:06:38 +0000

Introduction

As enterprise applications grow, their complexity increases. One key practice to keep code manageable is to separate business logic from controllers or data access code. That’s where the Service Layer Pattern comes in.

Documented in Martin Fowler’s Catalog of Patterns of Enterprise Application Architecture, this pattern proposes isolating all business rules into a dedicated layer, improving modularity, scalability, and testability.

What is the Service Layer Pattern?

The Service Layer acts as an intermediate layer between the application interface (e.g., API, UI) and the domain or persistence layers. It groups domain operations that follow business rules.

Why use it?

Avoid duplicated logic across controllers.
Organize and centralize business rules.
Make the system easier to maintain and test.

Real-World Example in Python

Let’s build a basic system to manage purchase orders. We’ll implement:

Order model
OrderRepository to simulate storage
OrderService with business rules

Project Structure

project/
├── models.py
├── order_repository.py
├── order_service.py
└── main.py

models.py

class Order:
    def __init__(self, order_id, customer, total):
        self.id = order_id
        self.customer = customer
        self.total = total
        self.status = "PENDING"

    def approve(self):
        if self.total > 0:
            self.status = "APPROVED"

order_repository.py

class OrderRepository:
    def __init__(self):
        self.orders = []

    def add(self, order):
        self.orders.append(order)

    def list_all(self):
        return self.orders

order_service.py

from models import Order
from order_repository import OrderRepository

class OrderService:
    def __init__(self, repository: OrderRepository):
        self.repository = repository

    def create_order(self, order_id, customer, total):
        if total <= 0:
            raise ValueError("Total must be greater than zero")
        order = Order(order_id, customer, total)
        self.repository.add(order)
        return order

    def approve_order(self, order_id):
        for order in self.repository.list_all():
            if order.id == order_id:
                order.approve()
                return order
        raise ValueError("Order not found")

main.py

from order_repository import OrderRepository
from order_service import OrderService

repo = OrderRepository()
service = OrderService(repo)

# Create valid order
order = service.create_order(1, "Client A", 150.0)
print(f"Created order: {order.customer}, total: {order.total}, status: {order.status}")

# Approve the order
approved = service.approve_order(1)
print(f"Updated order: {approved.customer}, status: {approved.status}")

🔍 Code Explanation

Order: represents a purchase order.
OrderRepository: stores the orders in memory.
OrderService: handles business logic, such as validation and approval rules.
main.py: simulates an application controller that uses the service layer.

Thanks to this pattern, business logic stays centralized and reusable, and we can test it independently.

Benefits of Service Layer Pattern

Benefit	Description
📦 Centralized	All business logic is grouped in one layer
♻ Reusable	Can be reused across different interfaces or systems
🧪 Testable	Easy to mock or test without touching the UI or DB
🧼 Clean Code	Controllers remain slim and focused on coordination

Conclusion

The Service Layer Pattern is ideal for growing applications that require strong structure and separation of concerns. It ensures the application remains maintainable, organized, and ready for scaling new features without increasing technical debt.

🔗 YouTube

https://youtu.be/NdL-Sr-U9xw

📰 github
https://github.com/daniellupaca/Software-Design-Principles-Applying-KISS-and-YAGNI-with-a-Real-Python-Example.git

Software Design Principles: Applying KISS and YAGNI with a Real Python Example

Ronal Daniel LUPACA MAMANI — Wed, 30 Apr 2025 22:20:45 +0000

Introduction

Applying design principles in software development helps create cleaner, more efficient, and easier-to-maintain systems. This article introduces two essential principles —KISS and YAGNI— using a real-world example written in Python. The goal is to demonstrate how to write focused and effective code from the beginning without overengineering.

What is KISS?

KISS stands for "Keep It Simple, Stupid". This principle encourages developers to keep their code as simple as possible. Simpler code is easier to read, debug, maintain, and extend when needed.

What is YAGNI?

YAGNI means "You Aren’t Gonna Need It". It reminds developers to avoid building features based on hypothetical future needs. Instead, focus on writing only what is needed today, not what might be useful someday.

Python Code Example

tasks = []

def add_task(description):
    tasks.append({"description": description, "done": False})

def list_tasks():
    for i, task in enumerate(tasks, 1):
        status = "✔" if task["done"] else "✘"
        print(f"{i}. [{status}] {task['description']}")

def complete_task(index):
    if 0 < index <= len(tasks):
        tasks[index - 1]["done"] = True

# Example usage:
add_task("Finish article for Dev.to")
add_task("Record explanation video")
list_tasks()
complete_task(1)
list_tasks()

Code Explanation

tasks = []: initializes an empty list to hold task entries.

add_task(description): appends a dictionary with task description and a default “not done” status.

list_tasks(): displays each task with its number, a checkmark (✔) if completed or ✘ if not, and the description.

complete_task(index): updates the selected task's status to completed based on the index provided.

The last lines show a usage example: adding tasks, listing them, completing one, and listing again to see the updated state.

Conclusion

This example shows that simple, readable code can effectively solve real problems without overcomplication. By following KISS and YAGNI, developers can produce working solutions that are easy to maintain and evolve later, if truly needed.

🔗 Watch on YouTube
https://youtu.be/D60EM7-0-Es

📰 github
https://github.com/daniellupaca/Research-Group-Activity-Design-Principles.git

Building an Application with Debezium and Kafka

Ronal Daniel LUPACA MAMANI — Thu, 12 Dec 2024 04:51:32 +0000

Course: TÓPICOS DE BASE DE DATOS A

Teacher: Mag. Patrick Cuadros Quiroga

Introduction

In modern application development, real-time synchronization and updates of data are constant challenges. Change Data Capture (CDC) tools like Debezium allow monitoring and transmitting changes made to a database to consuming systems, enabling more scalable and reactive architectures. This article presents how to build an application using Debezium and Kafka to capture and process changes in a relational database.

Why Choose Debezium and Kafka?

Debezium: Provides an efficient and reliable way to capture changes in databases like MySQL, PostgreSQL, SQL Server, among others. It is easy to configure and allows capturing insert, update, and delete events.
Kafka: Acts as the message broker that transports captured events to consumers, ensuring scalability and efficient real-time data handling.

Methodology

1. Environment Setup

Use Docker to deploy containers for Kafka, Zookeeper, Debezium, and a MySQL database.
Configure Debezium connectors to monitor a database.

2. Application Development

Configure a consumer in Python using the confluent-kafka library to process change events.
Design application logic to react to the processed events.

3. Testing and Deployment

Test the application with CRUD operations on the database and verify the real-time processing of captured events.
Deploy the application using a local or cloud environment.

Implementation

1. Environment Setup with Docker

Create a docker-compose.yml file to deploy Kafka, Zookeeper, MySQL, and Debezium:

version: '3.8'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181

  kafka:
    image: confluentinc/cp-kafka:latest
    ports:
      - "9092:9092"
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: test_db

  debezium:
    image: debezium/connect:latest
    ports:
      - "8083:8083"
    environment:
      BOOTSTRAP_SERVERS: kafka:9092
      GROUP_ID: debezium-connect

2. Configure Debezium Connector

Send the connector configuration to the Debezium endpoint

curl -X POST -H "Content-Type: application/json" \
     --data '{
         "name": "mysql-connector",
         "config": {
             "connector.class": "io.debezium.connector.mysql.MySqlConnector",
             "tasks.max": "1",
             "database.hostname": "mysql",
             "database.port": "3306",
             "database.user": "root",
             "database.password": "root",
             "database.server.id": "1",
             "database.server.name": "dbserver1",
             "database.include.list": "test_db",
             "database.history.kafka.bootstrap.servers": "kafka:9092",
             "database.history.kafka.topic": "schema-changes.test_db"
         }
     }' \
     http://localhost:8083/connectors

3. Develop the Consumer in Python

Create a consumer using the confluent-kafka library

from confluent_kafka import Consumer, KafkaException

consumer_config = {
    'bootstrap.servers': 'localhost:9092',
    'group.id': 'python-consumer',
    'auto.offset.reset': 'earliest'
}

consumer = Consumer(consumer_config)
consumer.subscribe(['dbserver1.test_db.test_table'])

try:
    while True:
        msg = consumer.poll(1.0)
        if msg is None:
            continue
        if msg.error():
            raise KafkaException(msg.error())
        print(f"Received message: {msg.value().decode('utf-8')}")
finally:
    consumer.close()

Results

The application captures real-time change events in the MySQL database, processes them using Kafka and Debezium, and consumes them via the Python client. Tests showed that operations like inserts, updates, and deletions in the database are instantly reflected in the processed messages.

Conclusion

Using tools like Debezium and Kafka simplifies the implementation of reactive and scalable data architectures. This project demonstrates how to efficiently capture and process database changes, enabling real-time applications.

GitHub Repository

The source code for the application is available at the following GitHub link:

Project Repository

References

Debezium Documentation. https://debezium.io/
Kafka Documentation. https://kafka.apache.org/
Docker Documentation. https://docs.docker.com/

Creating an Application with Amazon RDS and MySQL in the Cloud

Ronal Daniel LUPACA MAMANI — Wed, 11 Dec 2024 16:56:26 +0000

Course: TÓPICOS DE BASE DE DATOS A

Teacher: Mag. Patrick Cuadros Quiroga

Introduction

Modern application development has shifted towards cloud-based solutions due to their scalability, flexibility, and ease of integration. Cloud databases play a crucial role by enabling developers to manage data efficiently and securely. This article discusses the creation of an application using Amazon RDS with MySQL as a cloud-hosted SQL database, exploring the advantages of this architecture and outlining the workflow for its implementation. The choice of Amazon RDS and MySQL is based on its simplified management, reliable performance, and automated scalability.

Advantages of Using Amazon RDS with MySQL

Simplified Management: Amazon RDS handles administrative tasks like software updates, automated backups, and disaster recovery.
Scalability: Easily scale storage and compute capacity to accommodate application growth.
Security: Provides advanced security measures, including encryption for data in transit and at rest.
Compatibility: MySQL is widely compatible with existing tools and applications, easing integration.
Cost Efficiency: Offers pay-as-you-go options, reducing upfront costs and ensuring a scalable model.

Methodology

Selection of Cloud Database Provider

For this project, Amazon RDS with MySQL was chosen as the cloud database due to its managed configuration, scalability, and compatibility with various applications.

Environment Configuration

Creating a database instance in Amazon RDS.
Configuring parameters such as storage size, MySQL version, and security settings to allow controlled access from the application.
Generating secure credentials for database connection.

Application Development

The application was developed using Python with the Flask framework to manage backend operations. Key functionalities include:

User registration.
Secure session management.
CRUD (Create, Read, Update, Delete) operations for data stored in the database.

The frontend was designed with HTML, CSS, and Bootstrap for an appealing and responsive interface.

Sample Code for Database Connection

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://username:password@database-endpoint:3306/database_name'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return f'<User {self.name}>'

if __name__ == '__main__':
    db.create_all()
    app.run(debug=True)

Results and Discussion

The application demonstrated stable performance in data management and communication with the cloud database. Using Amazon RDS abstracted complex tasks such as hardware configuration, patch management, and automated backups. Additionally, the modular design of the application facilitates future updates or migrations to other cloud services.

Conclusions

Cloud-hosted SQL databases are an efficient and secure solution for managing data in modern applications.
Amazon RDS with MySQL provided a robust platform to implement the database without the need for physical servers.
The integration between the application and database was simplified with libraries like SQLAlchemy and AWS support.
This project lays the foundation for exploring advanced functionalities, such as data analysis and AI integration, to enhance user experience.

GitHub Repository

The source code for the application is available at the following GitHub link:

Project Repository

References

Amazon Web Services. "Amazon RDS Documentation." https://aws.amazon.com/rds/.
Flask Documentation. "Flask, Web Development." https://flask.palletsprojects.com/.
SQLAlchemy Documentation. "SQLAlchemy ORM." https://www.sqlalchemy.org/.

Creating an Application with Amazon RDS and MySQL in the Cloud

Ronal Daniel LUPACA MAMANI — Wed, 11 Dec 2024 16:56:26 +0000

Course: TÓPICOS DE BASE DE DATOS A

Teacher: Mag. Patrick Cuadros Quiroga

Introduction

Advantages of Using Amazon RDS with MySQL

Simplified Management: Amazon RDS handles administrative tasks like software updates, automated backups, and disaster recovery.
Scalability: Easily scale storage and compute capacity to accommodate application growth.
Security: Provides advanced security measures, including encryption for data in transit and at rest.
Compatibility: MySQL is widely compatible with existing tools and applications, easing integration.
Cost Efficiency: Offers pay-as-you-go options, reducing upfront costs and ensuring a scalable model.

Methodology

Selection of Cloud Database Provider

For this project, Amazon RDS with MySQL was chosen as the cloud database due to its managed configuration, scalability, and compatibility with various applications.

Environment Configuration

Creating a database instance in Amazon RDS.
Configuring parameters such as storage size, MySQL version, and security settings to allow controlled access from the application.
Generating secure credentials for database connection.

Application Development

The application was developed using Python with the Flask framework to manage backend operations. Key functionalities include:

User registration.
Secure session management.
CRUD (Create, Read, Update, Delete) operations for data stored in the database.

The frontend was designed with HTML, CSS, and Bootstrap for an appealing and responsive interface.

Sample Code for Database Connection

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://username:password@database-endpoint:3306/database_name'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return f'<User {self.name}>'

if __name__ == '__main__':
    db.create_all()
    app.run(debug=True)

Results and Discussion

Conclusions

Cloud-hosted SQL databases are an efficient and secure solution for managing data in modern applications.
Amazon RDS with MySQL provided a robust platform to implement the database without the need for physical servers.
The integration between the application and database was simplified with libraries like SQLAlchemy and AWS support.
This project lays the foundation for exploring advanced functionalities, such as data analysis and AI integration, to enhance user experience.

GitHub Repository

The source code for the application is available at the following GitHub link:

Project Repository

References

Amazon Web Services. "Amazon RDS Documentation." https://aws.amazon.com/rds/.
Flask Documentation. "Flask, Web Development." https://flask.palletsprojects.com/.
SQLAlchemy Documentation. "SQLAlchemy ORM." https://www.sqlalchemy.org/.

#Creating an Application with Firestore: A NoSQL Alternative from Google

Ronal Daniel LUPACA MAMANI — Sat, 26 Oct 2024 13:56:12 +0000

Author: [Ronal Daniel Lupaca Mamani]

Introduction

Today, mobile and web applications increasingly require a database that enables real-time synchronization without the complexity of an SQL server. Google Firestore, a NoSQL cloud database, offers exactly that: real-time storage and scalability without the need to manage servers. In this article, I want to show you how to create a simple To-Do List application using Firestore to perform CRUD operations (Create, Read, Update, and Delete).

Firestore is ideal for this type of application as it allows data to be stored and synchronized in real-time across multiple devices. Moreover, its integration with Firebase makes it a powerful tool for web and mobile applications.

What is Firestore?

Firestore is part of Google's Firebase platform and is a NoSQL cloud database that allows real-time data storage and synchronization. Firestore organizes data into documents and collections, which is ideal for structured data and allows us to have a serverless database. Some key features include:

Real-time synchronization: Data is instantly updated on all connected devices.
Automatic scalability: It can handle large volumes of data and traffic seamlessly.
Integration with Firebase and Google Cloud Platform: It is easy to add authentication and permissions.

Project Goal

In this project, I want to create a To-Do List application where we can:

Add new tasks.
View all stored tasks.
Edit and delete tasks.
Automatically synchronize data in real-time.

Project Structure

We organize the application into the following files:

index.html: The application's user interface.
style.css: The application's styles.
app.js: The application logic and Firestore connection.

Step 1: Firestore Setup in Firebase

Create a Project in Firebase:
- Log in to the Firebase Console and create a new project.
Enable Firestore:
- In the Firebase console, go to the Firestore Database section and enable it in test mode (for development).
Download the Configuration File:
- In the project settings, select "Add web app" to obtain the configuration file (firebaseConfig), necessary to connect the application to Firebase.

Step 2: Create the User Interface (index.html)

In index.html, we set up a simple interface with a form to add tasks and a list where stored tasks will be displayed:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>To-Do List with Firestore</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <h1>To-Do List</h1>
    <form id="taskForm">
        <input type="text" id="newTask" placeholder="New task..." required>
        <button type="submit">Add</button>
    </form>
    <ul id="taskList"></ul>
    <script src="https://www.gstatic.com/firebasejs/9.6.0/firebase-app.js"></script>
    <script src="https://www.gstatic.com/firebasejs/9.6.0/firebase-firestore.js"></script>
    <script src="app.js"></script>
</body>
</html>

Step 3: Application Styles (style.css)

This file provides a simple design for the application:

body {
    font-family: Arial, sans-serif;
    display: flex;
    flex-direction: column;
    align-items: center;
    background-color: #f4f4f9;
}
h1 {
    color: #333;
}
form {
    margin: 15px;
}
input, button {
    padding: 10px;
    margin: 5px;
}
ul {
    list-style: none;
    padding: 0;
    width: 300px;
}
li {
    background-color: #ececec;
    margin: 5px;
    padding: 10px;
    display: flex;
    justify-content: space-between;
}

Step 4: Application Logic and Firestore Connection (app.js)

This file contains the application logic and the CRUD functions that interact with Firestore:

// Firebase Configuration
const firebaseConfig = {
    apiKey: "YOUR_API_KEY",
    authDomain: "YOUR_AUTH_DOMAIN",
    projectId: "YOUR_PROJECT_ID",
    storageBucket: "YOUR_STORAGE_BUCKET",
    messagingSenderId: "YOUR_MESSAGING_SENDER_ID",
    appId: "YOUR_APP_ID"
};

// Initialize Firebase
firebase.initializeApp(firebaseConfig);
const db = firebase.firestore();

// Function to load all tasks
function loadTasks() {
    const taskList = document.getElementById("taskList");
    taskList.innerHTML = "";

    db.collection("tasks").onSnapshot((snapshot) => {
        snapshot.forEach((doc) => {
            const task = doc.data().task;
            const li = document.createElement("li");
            li.textContent = task;
            li.appendChild(createDeleteButton(doc.id));
            taskList.appendChild(li);
        });
    });
}

// Function to add a new task
document.getElementById("taskForm").addEventListener("submit", async (e) => {
    e.preventDefault();
    const newTaskInput = document.getElementById("newTask");
    const newTask = newTaskInput.value.trim();

    if (newTask) {
        await db.collection("tasks").add({ task: newTask });
        newTaskInput.value = "";
    }
});

// Function to delete a task
function createDeleteButton(id) {
    const btn = document.createElement("button");
    btn.textContent = "Delete";
    btn.onclick = async () => {
        await db.collection("tasks").doc(id).delete();
    };
    return btn;
}

// Load tasks when the application starts
document.addEventListener("DOMContentLoaded", loadTasks);

Advantages of Using Firestore

Real-time Synchronization: Firestore allows all connected devices to synchronize data automatically.
Automatic Scalability: Firestore handles large amounts of data and traffic without manual adjustments.
Built-in Security: With Firebase Authentication integration, it's easy to apply access rules and protect data.

Conclusion

Creating this To-Do List application with Firestore allowed me to explore a NoSQL cloud database that is excellent for storing and synchronizing data in real-time. Thanks to Firestore, I can avoid setting up an SQL server and simplify the development process, which is ideal for collaborative or lightweight applications.

GitHub Code Link: https://github.com/daniellupaca/C-mo-Crear-una-Lista-de-Tareas-sin-Bases-de-Datos-SQL-Redis-ni-MongoDB.git

References

Google Developers. (n.d.). Firebase Firestore Documentation. Firebase.
Firebase. (n.d.). Firestore Introduction. Google Cloud Platform.

# Cómo Crear una Lista de Tareas sin Bases de Datos SQL, Redis ni MongoDB

Ronal Daniel LUPACA MAMANI — Fri, 25 Oct 2024 17:13:47 +0000

Introducción

Desarrollar aplicaciones web suele implicar el uso de bases de datos para almacenar y gestionar datos. Sin embargo, cuando trabajamos en aplicaciones ligeras, existen alternativas que evitan la necesidad de un servidor de base de datos. Este artículo presenta una manera de crear una aplicación de lista de tareas (To-Do List) sin SQL, MongoDB o Redis, aprovechando localStorage del navegador para la persistencia de datos y manteniendo la aplicación sencilla y eficiente.

Características de la Aplicación

Almacenamiento Local en el Navegador:
- Esta aplicación utiliza localStorage para almacenar y cargar tareas. Al no requerir una base de datos, los datos se guardan directamente en el navegador del usuario, haciendo que esta solución sea adecuada para prototipos y aplicaciones pequeñas.
Interfaz Intuitiva y Ligera:
- Diseñada con HTML y CSS, la interfaz es simple pero efectiva. Permite al usuario agregar tareas en segundos y visualizarlas sin complicaciones.
Fácil de Mantener y Extender:
- Con lógica escrita en JavaScript puro, el código es fácil de entender y modificar, haciéndolo ideal para aquellos que buscan aprender sobre desarrollo de aplicaciones sin bases de datos complejas.

1. Estructura de Archivos

Para organizar la aplicación, utilizamos cuatro archivos:

index.html: Define la estructura visual de la aplicación, con un formulario para añadir tareas y una lista donde se muestran las tareas guardadas.
style.css: Contiene los estilos visuales, creando una apariencia limpia y amigable.
script.js: Controla toda la lógica de la aplicación, como cargar y guardar tareas en localStorage.
tasks.json: Este archivo incluye datos de ejemplo de tareas, que podrían integrarse en una futura actualización.

2. Creación de la Interfaz de Usuario (index.html)

Este archivo define la estructura básica de la aplicación y permite al usuario interactuar con la lista de tareas. Incluye un formulario que permite añadir tareas y una lista que muestra todas las tareas almacenadas.

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Lista de Tareas sin Base de Datos</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <h1>Lista de Tareas</h1>
    <form id="taskForm">
        <input type="text" id="newTask" placeholder="Nueva tarea...">
        <button type="submit">Agregar</button>
    </form>
    <ul id="taskList"></ul>
    <script src="script.js"></script>
</body>
</html>

3. Estilo Visual de la Aplicación (style.css)

El diseño de la aplicación es simple para garantizar una experiencia clara y fácil de usar. Usamos CSS básico para los elementos de la página y definimos colores y márgenes para hacerla más atractiva visualmente.

body {
    font-family: Arial, sans-serif;
    display: flex;
    flex-direction: column;
    align-items: center;
    background-color: #f4f4f9;
}
h1 {
    color: #333;
}
form {
    margin: 15px;
}
input, button {
    padding: 10px;
    margin: 5px;
}
ul {
    list-style: none;
    padding: 0;
    width: 300px;
}
li {
    background-color: #ececec;
    margin: 5px;
    padding: 10px;
}

4. Lógica de la Aplicación (script.js)

Toda la lógica de la aplicación se controla desde este archivo JavaScript, que incluye funciones para cargar las tareas desde localStorage, agregar nuevas tareas y mantener los datos actualizados.

loadTasks(): Se ejecuta al cargar la página, obtiene las tareas de localStorage y las muestra en la lista de tareas.
saveTask(task): Guarda una nueva tarea en localStorage.
Formulario de Tareas: Captura el evento submit para agregar tareas sin recargar la página.

document.addEventListener('DOMContentLoaded', loadTasks);

function loadTasks() {
    const taskList = document.getElementById('taskList');
    const tasks = JSON.parse(localStorage.getItem('tasks')) || [];
    taskList.innerHTML = '';
    tasks.forEach(task => {
        const li = document.createElement('li');
        li.textContent = task;
        taskList.appendChild(li);
    });
}

document.getElementById('taskForm').addEventListener('submit', function (e) {
    e.preventDefault();
    const newTaskInput = document.getElementById('newTask');
    const newTask = newTaskInput.value.trim();
    if (newTask) {
        saveTask(newTask);
        newTaskInput.value = '';
        loadTasks();
    }
});

function saveTask(task) {
    const tasks = JSON.parse(localStorage.getItem('tasks')) || [];
    tasks.push(task);
    localStorage.setItem('tasks', JSON.stringify(tasks));
}

5. Archivo JSON con Datos Iniciales (tasks.json)

Este archivo contiene datos de ejemplo que podrían utilizarse para poblar la lista de tareas en una versión futura de la aplicación. Aunque no se carga dinámicamente en esta versión, proporciona un ejemplo de cómo se podrían almacenar las tareas inicialmente.

[
    "Completar proyecto de la universidad",
    "Leer un libro de ciencia ficción",
    "Hacer ejercicio"
]

Explicación del Uso de localStorage

En lugar de una base de datos de servidor, esta aplicación utiliza localStorage, una API de almacenamiento en el navegador que permite guardar datos de manera simple y rápida.

Simplicidad: localStorage permite guardar datos en formato JSON directamente en el navegador, evitando la configuración de una base de datos.
Persistencia Local: Los datos guardados en localStorage permanecen disponibles mientras no se borren manualmente los datos del navegador, proporcionando persistencia sin necesidad de conexión al servidor.

En esta aplicación:

Carga de Tareas: loadTasks() recupera las tareas guardadas y las muestra al usuario.
Agregar Nuevas Tareas: saveTask() guarda cada tarea nueva en localStorage.
Sesiones Persistentes: Las tareas se mantienen entre sesiones, siempre que el usuario no borre los datos de su navegador.

Ventajas del Uso de localStorage

Fácil de Implementar: No requiere configuraciones adicionales, por lo que es ideal para aplicaciones pequeñas.
Persistencia entre Sesiones: Las tareas se mantienen en localStorage entre sesiones, lo cual es útil para datos no sensibles.
Rendimiento Rápido: localStorage funciona directamente en el navegador, eliminando la necesidad de llamadas a un servidor y mejorando la velocidad.

Conclusión

Este artículo ha demostrado cómo crear una aplicación de lista de tareas sin depender de bases de datos de servidor. localStorage ofrece una solución sencilla para almacenar y recuperar datos, lo que convierte esta aplicación en una excelente opción para prototipos y aplicaciones pequeñas.

# Comparative Analysis of Testing Management Tools: TeamCity

Ronal Daniel LUPACA MAMANI — Fri, 05 Jul 2024 00:24:47 +0000

Teacher: Mag. Patrick Cuadros Quiroga

Member: Lupaca Mamani, Ronal Daniel

INTRODUCTION

In today’s software development environment, ensuring the quality and functionality of applications is paramount. Continuous Integration (CI) and Continuous Delivery (CD) tools play a crucial role in automating development and deployment processes. TeamCity, developed by JetBrains, is one of the most popular and widely adopted CI/CD tools in the industry. This article will explore TeamCity’s functionalities, showcasing how it can be effectively used for testing management and code comparison.

BODY

What is TeamCity?

TeamCity is a powerful CI/CD server designed to automate the build, test, and release processes, ensuring the smooth delivery of high-quality software. Since its initial release in 2006, TeamCity has become a favorite among developers for its robust features and user-friendly interface.

Key Features of TeamCity:

Extensibility: TeamCity supports a wide range of plugins, allowing integration with various tools and platforms.
Build Pipelines: It allows defining complex build pipelines, providing flexibility in automating workflows.
Scalability: TeamCity can handle projects of any size, from small startups to large enterprises.
Comprehensive VCS Integration: It integrates seamlessly with multiple version control systems, including Git, Subversion, and Mercurial.
Real-time Feedback: Provides immediate feedback on build status, helping teams to quickly identify and address issues.

Advantages of TeamCity:

Customizable Build Configurations: Its build configuration system is highly flexible, supporting various environments and platforms.
Strong Community Support: A vibrant community provides plugins, updates, and support.
Detailed Reporting: Offers extensive reporting features that help track the build process and quality metrics.

Disadvantages of TeamCity:

Resource Intensive: Requires substantial server resources to run efficiently.
Learning Curve: May be complex for new users to configure and manage.
Maintenance Overhead: Requires regular maintenance to manage updates and ensure security.

Managing Tests with TeamCity

TeamCity provides a robust environment for managing automated tests, from execution to result visualization. Here’s how TeamCity can be used effectively in a real-world scenario:

Configuration of Projects and Builds:
- Creating a Project: When starting a new project in TeamCity, you can define specific build configurations for different environments, which allows you to tailor your CI/CD pipeline to meet project-specific needs.
- Build Steps: Add build steps that include running unit, integration, and functional tests. Tools like JUnit, NUnit, or TestNG can be easily integrated into TeamCity's build process.
Integration with Testing Tools:
- JUnit: TeamCity can execute JUnit tests as part of your CI/CD pipeline, collecting and presenting results in its interface for easy review.
- Selenium: Integrate Selenium for automated functional testing. TeamCity can run these tests across various browsers, reporting results in real-time.
Reporting Results:
- Dashboards and Test Views: Test results are displayed on detailed dashboards, including graphs and statistics that help visualize the state and quality of the code efficiently.
- Notifications: Configure notifications in TeamCity to alert developers of test failures, ensuring a quick and proactive response to identified issues.

Code Comparison in TeamCity

Code comparison is essential to maintain software quality and consistency. TeamCity offers advanced functionalities to facilitate this process:

Integration with Version Control Systems (VCS):
- Git, Mercurial, Subversion: TeamCity integrates seamlessly with popular version control systems, allowing code comparison and merging directly from its interface.
- Branching and Merging: TeamCity supports advanced branching and merging strategies, helping teams manage and review code changes efficiently. This is particularly useful in large projects with multiple developers working in parallel.
Code Inspection:
- Static Code Analysis: Integrating static code analysis tools in TeamCity helps identify potential issues in the code before they reach production. This includes error detection, coding best practices, and security issues.
- Pull Requests: Configure builds to run automatically when a pull request is created, ensuring all proposed changes are validated before merging. TeamCity's code review functionalities allow comparison of changes and ensure quality before final integration.

Real-World Example

Below is a practical example of a TeamCity pipeline for managing tests and performing code comparisons. This pipeline sets up the environment, runs tests, simulates a code review, and archives the results.

Example Pipeline

Setting Up JDK and Running Unit Tests with JUnit

This pipeline sets up the environment with JDK 17, runs unit tests using JUnit, and archives the test results.

Environment Setup and Unit Tests:

project {
    name = "Example Project"

    buildType {
        name = "Build and Test"

        vcs {
            root(DslContext.settingsRoot)
        }

        steps {
            script {
                name = "Setup JDK"
                scriptContent = """
                    export JAVA_HOME=/usr/lib/jvm/java-17-openjdk
                    export PATH=$JAVA_HOME/bin:$PATH
                    java -version
                """
            }
            script {
                name = "Run Unit Tests"
                scriptContent = """
                    ./gradlew test
                """
            }
        }

        features {
            junit {
                includePattern = "**/build/test-results/test/*.xml"
            }
        }
    }
}

Explanation:

Environment Setup: Configures JDK 17 in the TeamCity environment.
Running Unit Tests: Executes unit tests using Gradle.
Reporting Results: Configures TeamCity to collect and display JUnit test results.
Simulating Test Results and Archiving Results:

project {
    name = "Example Project"

    buildType {
        name = "Build and Test"

        vcs {
            root(DslContext.settingsRoot)
        }

        steps {
            script {
                name = "Setup JDK"
                scriptContent = """
                    export JAVA_HOME=/usr/lib/jvm/java-17-openjdk
                    export PATH=$JAVA_HOME/bin:$PATH
                    java -version
                """
            }
            script {
                name = "Run Unit Tests"
                scriptContent = """
                    ./gradlew test
                """
            }
            script {
                name = "Simulate Test Results"
                scriptContent = """
                    echo "Test Results: All tests passed!" > test-results.txt
                    tar -czf test-results.tar.gz test-results.txt
                """
            }
        }

        artifacts {
            artifactRules = "test-results.tar.gz"
        }

        features {
            junit {
                includePattern = "**/build/test-results/test/*.xml"
            }
        }
    }
}

Explanation:

Simulating Test Results: Creates a file with the test results and compresses it.
Archiving Results: Configures TeamCity to archive the test results.

CONCLUSION

TeamCity is a powerful and versatile tool that not only facilitates continuous integration and delivery but also provides essential functionalities for test management and code comparison. Its ability to integrate with version control systems and testing tools makes it an ideal choice for development teams aiming to maintain high standards of quality and efficiency in their projects.

#Rest-Assured: A Powerful Framework for RESTful API Testing

Ronal Daniel LUPACA MAMANI — Sat, 08 Jun 2024 07:38:11 +0000

Ronal Daniel Lupaca Mamani

Rest-Assured is a Java library specifically designed to facilitate testing of RESTful services. Its simplicity and effectiveness have made Rest-Assured a popular tool among developers and testers looking to validate HTTP responses and verify data in JSON and XML formats.

Key Features

BDD Style Syntax: Rest-Assured allows you to write tests in a Behavior Driven Development (BDD) style, making your tests more readable and maintainable.
Support for JSON and XML: Makes it easy to work with data in JSON and XML format, two of the most common formats in modern APIs.
Integration with Test Frameworks: Integrates seamlessly with test frameworks such as JUnit and TestNG, allowing for simple and familiar test execution.
Wide Range of Verification Methods: Offers a variety of methods for validating responses, including HTTP status codes, response structures, and specific values in the returned data.

Real-World Example

Here's a simple example that demonstrates how to use Rest-Assured to make a GET request and validate the response:

import io.restassured.RestAssured;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class ApiTest {
    public void getUsers() {
        RestAssured.baseURI = "http://api.ejemplo.com";
        given().
            when().
                get("/users").
            then().
                statusCode(200).
                body("data.size()", greaterThan(0));
    }
}

Code Explanation

Base URI: The base URI is set for REST requests. In this case, http://api.ejemplo.com.
GET Request: A GET request is made to the /users endpoint.
Validations:
- The status code of the response is verified to be 200, indicating a successful request.
- It ensures that the size of the data array in the response is greater than 0, validating that user data is returned.

Advantages of Using Rest-Assured

Ease of Use: Rest-Assured's syntax is simple and straightforward, reducing the learning curve and allowing development and testing teams to get started quickly.
Extensive Documentation: It has complete and detailed documentation that facilitates the resolution of doubts and problems during implementation.
Flexibility: Supports a large number of HTTP operations and data formats, adapting to the needs of most modern applications.

Conclusion

Rest-Assured is a powerful and accessible tool for testing RESTful APIs. Its ease of use, combined with its advanced capabilities, make it an ideal choice for both developers and testers. Implementing Rest-Assured into your testing workflow can significantly improve the quality and reliability of your APIs, ensuring they meet expectations for functionality and performance.

DEV Community: Ronal Daniel LUPACA MAMANI

# 🔍 Observability with Prometheus in PHP

🎯 What will you learn?

🧰 Tools used

🧪 Step 1: Generate metrics from PHP

📄 generator.php

📄 metrics.php

▶️ Step 2: Run the scripts

⚙️ Step 3: Configure Prometheus

▶️ Step 4: Run Prometheus

📈 Step 5: Query metrics in Prometheus

📊 1. upload_processing_seconds

📦 2. uploads_total

📦 GitHub Repository

🧠 Conclusion

❤️ Was this useful?

# 🛰️ Observabilidad en PHP con Prometheus

🎯 ¿Qué aprenderás?

🧰 Herramientas utilizadas

🧪 Paso 1: Generar métricas desde PHP

📄 generador.php

📄 metrics.php

▶️ Paso 2: Ejecutar los scripts

⚙️ Paso 3: Configurar Prometheus

▶️ Paso 4: Ejecutar Prometheus

📈 Paso 5: Consultar métricas en Prometheus

📊 1. upload_processing_seconds

📦 2. uploads_total

📦 Repositorio de código

🧠 Conclusión

❤️ ¿Te fue útil?

Enterprise Design Pattern: Implementing the Service Layer Pattern in Python

Introduction

What is the Service Layer Pattern?

Why use it?

Real-World Example in Python

Project Structure

models.py

order_repository.py

order_service.py

main.py

🔍 Code Explanation

Benefits of Service Layer Pattern

Conclusion

Software Design Principles: Applying KISS and YAGNI with a Real Python Example

Introduction

What is KISS?

What is YAGNI?

Python Code Example

Code Explanation

Conclusion

Building an Application with Debezium and Kafka

Course: TÓPICOS DE BASE DE DATOS A

Teacher: Mag. Patrick Cuadros Quiroga

Introduction

Why Choose Debezium and Kafka?

Methodology

1. Environment Setup

2. Application Development

3. Testing and Deployment

Implementation

1. Environment Setup with Docker

2. Configure Debezium Connector

Send the connector configuration to the Debezium endpoint

3. Develop the Consumer in Python

Create a consumer using the confluent-kafka library

Results

Conclusion

GitHub Repository

References

Creating an Application with Amazon RDS and MySQL in the Cloud

Course: TÓPICOS DE BASE DE DATOS A

Teacher: Mag. Patrick Cuadros Quiroga

Introduction

Advantages of Using Amazon RDS with MySQL

Methodology

Selection of Cloud Database Provider

Environment Configuration

Application Development

Sample Code for Database Connection

📄 `generator.php`

📄 `metrics.php`

📊 1. `upload_processing_seconds`

📦 2. `uploads_total`

📄 `generador.php`

📄 `metrics.php`

📊 1. `upload_processing_seconds`

📦 2. `uploads_total`