Reading view

There are new articles available, click to refresh the page.

Locust ep 5: How to use test_start and test_stop Events in Locust

Locust provides powerful event hooks, such as test_start and test_stop, to execute custom logic before and after a load test begins or ends. These events allow you to implement setup and teardown operations at the test level, which applies to the entire test run rather than individual users.

In this blog, we will

  1. Understand what test_start and test_stop are.
  2. Explore their use cases.
  3. Provide examples of implementing these events.
  4. Discuss how to run and validate the setup.

What Are test_start and test_stop?

  • test_start: Triggered when the test starts. Use this event to perform actions like initializing global resources, starting external systems, or logging test start information.
  • test_stop: Triggered when the test ends. This event is ideal for cleanup operations, aggregating results, or stopping external systems.

These events are global and apply to the entire test environment rather than individual user instances.

Why Use test_start and test_stop?

  • Global Setup: Initialize shared resources, like database connections or external services.
  • Logging: Record timestamps or test details for audit or reporting purposes.
  • External System Management: Start/stop services that the test depends on, such as mock servers or third-party APIs.

Example: Basic Usage of test_start and test_stop

Here’s a basic example demonstrating the usage of these events


from locust import User, task, between, events
from datetime import datetime

# Global setup: Perform actions at test start
@events.test_start.add_listener
def on_test_start(environment, **kwargs):
    print("Test started at:", datetime.now())

# Global teardown: Perform actions at test stop
@events.test_stop.add_listener
def on_test_stop(environment, **kwargs):
    print("Test stopped at:", datetime.now())

# Simulated user behavior
class MyUser(User):
    wait_time = between(1, 5)

    @task
    def print_datetime(self):
        """Task that prints the current datetime."""
        print("Current datetime:", datetime.now())

Running the Example

  • Save the code as locustfile.py.
  • Start Locust -> `locust -f locustfile.py`
  • Configure the test parameters (number of users, spawn rate, etc.) in the web UI at http://localhost:8089.
  • Observe the console output:
    • A message when the test starts (on_test_start).
    • Messages during the test as users execute tasks.
    • A message when the test stops (on_test_stop).

Example: Logging Test Details

You can log detailed test information, like the number of users and host under test, using environment and kwargs


from locust import User, task, between, events

@events.test_start.add_listener
def on_test_start(environment, **kwargs):
    print("Test started!")
    print(f"Target host: {environment.host}")
    print(f"Total users: {environment.runner.target_user_count}")

@events.test_stop.add_listener
def on_test_stop(environment, **kwargs):
    print("Test finished!")
    print("Summary:")
    print(f"Requests completed: {environment.stats.total.num_requests}")
    print(f"Failures: {environment.stats.total.num_failures}")

class MyUser(User):
    wait_time = between(1, 5)

    @task
    def dummy_task(self):
        pass

Observing the Results

When you run the above examples

  • At Test Start: Look for messages indicating setup actions, like initializing external systems or printing start time.
  • During the Test: Observe user tasks being executed.
  • At Test Stop: Verify that cleanup actions were executed successfully.

Locust ep 4: Why on_start and on_stop are Essential for Locust Users

Locust provides two special methods, on_start and on_stop, to handle setup and teardown actions for individual users. These methods allow you to execute specific code when a simulated user starts or stops, making it easier to simulate real-world scenarios like login/logout or initialization tasks.

In this blog, we’ll cover,

  1. What on_start and on_stop do.
  2. Why they are important.
  3. Practical examples of using these methods.
  4. Running and testing Locust scripts.

What Are on_start and on_stop?

  • on_start: This method is executed once when a new simulated user starts. It’s commonly used for tasks like logging in or setting up the environment.
  • on_stop: This method is executed once when a simulated user stops. It’s often used for cleanup tasks like logging out.

These methods are executed only once per user during the lifecycle of a test, as opposed to tasks that are run repeatedly.

Why Use on_start and on_stop?

  1. Simulating Real User Behavior: Real users often start a session with an action (e.g., login) and end it with another (e.g., logout).
  2. Initial Setup: Some tasks require initializing data or setting up user state before performing other actions.
  3. Cleanup: Ensure that actions like logout are performed to leave the system in a clean state.

Examples

Basic Usage of on_start and on_stop

In this example, we just print on start and `on stop` for each user while running a task.


from locust import User, task, between, constant, constant_pacing
from datetime import datetime


class MyUser(User):

    wait_time = between(1, 5)

    def on_start(self):
        print("on start")

    def on_stop(self):
        print("on stop")

    @task
    def print_datetime(self):
        print(datetime.now())

Locust EP 3: Simulating Multiple User Types in Locust

Locust allows you to define multiple user types in your load tests, enabling you to simulate different user behaviors and traffic patterns. This is particularly useful when your application serves diverse client types, such as web and mobile users, each with unique interaction patterns.

In this blog, we will

  1. Discuss the concept of multiple user types in Locust.
  2. Explore how to implement multiple user classes with weights.
  3. Run and analyze the test results.

Why Use Multiple User Types?

In real-world applications, different user groups interact with your system differently. For example,

  • Web Users might spend more time browsing through the UI.
  • Mobile Users could make faster but more frequent requests.

By simulating distinct user types with varying behaviors, you can identify performance bottlenecks across all client groups.

Understanding User Classes and Weights

Locust provides the ability to define user classes by extending the User or HttpUser base class. Each user class can,

  • Have a unique set of tasks.
  • Define its own wait times.
  • Be assigned a weight, which determines the proportion of that user type in the simulation.

For example, if WebUser has a weight of 1 and MobileUser has a weight of 2, the simulation will spawn 1 web user for every 2 mobile users.

Example: Simulating Web and Mobile Users

Below is an example Locust test with two user types


from locust import User, task, between

# Define a user class for web users
class MyWebUser(User):
    wait_time = between(1, 3)  # Web users wait between 1 and 3 seconds between tasks
    weight = 1  # Web users are less frequent

    @task
    def login_url(self):
        print("I am logging in as a Web User")


# Define a user class for mobile users
class MyMobileUser(User):
    wait_time = between(1, 3)  # Mobile users wait between 1 and 3 seconds
    weight = 2  # Mobile users are more frequent

    @task
    def login_url(self):
        print("I am logging in as a Mobile User")

How Locust Uses Weights

With the above configuration

  • For every 3 users spawned, 1 will be a Web User, and 2 will be Mobile Users (based on their weights: 1 and 2).

Locust automatically handles spawning these users in the specified ratio.

Running the Locust Test

  1. Save the Code
    Save the above code in a file named locustfile.py.
  2. Start Locust
    Open your terminal and run `locust -f locustfile.py`
  3. Access the Web UI
  4. Enter Test Parameters
    • Number of users (e.g., 30).
    • Spawn rate (e.g., 5 users per second).
    • Host: If you are testing an actual API or website, specify its URL (e.g., http://localhost:8000).
  5. Analyze Results
    • Observe how Locust spawns the users according to their weights and tracks metrics like request counts and response times.

After running the test:

  • Check the distribution of requests to ensure it matches the weight ratio (e.g., for every 1 web user request, there should be ~3 mobile user requests).
  • Use the metrics (response time, failure rate) to evaluate performance for each user type.

Locust EP 2: Understanding Locust Wait Times with Complete Examples

Locust is an excellent load testing tool, enabling developers to simulate concurrent user traffic on their applications. One of its powerful features is wait times, which simulate the realistic user think time between consecutive tasks. By customizing wait times, you can emulate user behavior more effectively, making your tests reflect actual usage patterns.

In this blog, we’ll cover,

  1. What wait times are in Locust.
  2. Built-in wait time options.
  3. Creating custom wait times.
  4. A full example with instructions to run the test.

What Are Wait Times in Locust?

In real-world scenarios, users don’t interact with applications continuously. After performing an action (e.g., submitting a form), they often pause before the next action. This pause is called a wait time in Locust, and it plays a crucial role in mimicking real-life user behavior.

Locust provides several ways to define these wait times within your test scenarios.

FastAPI App Overview

Here’s the FastAPI app that we’ll test,


from fastapi import FastAPI

# Create a FastAPI app instance
app = FastAPI()

# Define a route with a GET method
@app.get("/")
def read_root():
    return {"message": "Welcome to FastAPI!"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Locust Examples for FastAPI

1. Constant Wait Time Example

Here, we’ll simulate constant pauses between user requests


from locust import HttpUser, task, constant

class FastAPIUser(HttpUser):
    wait_time = constant(2)  # Wait for 2 seconds between requests

    @task
    def get_root(self):
        self.client.get("/")  # Simulates a GET request to the root endpoint

    @task
    def get_item(self):
        self.client.get("/items/42?q=test")  # Simulates a GET request with path and query parameters

2. Between wait time Example

Simulating random pauses between requests.


from locust import HttpUser, task, between

class FastAPIUser(HttpUser):
    wait_time = between(1, 5)  # Random wait time between 1 and 5 seconds

    @task(3)  # Weighted task: this runs 3 times more often
    def get_root(self):
        self.client.get("/")

    @task(1)
    def get_item(self):
        self.client.get("/items/10?q=locust")

3. Custom Wait Time Example

Using a custom wait time function to introduce more complex user behavior


import random
from locust import HttpUser, task

def custom_wait():
    return max(1, random.normalvariate(3, 1))  # Normal distribution (mean: 3s, stddev: 1s)

class FastAPIUser(HttpUser):
    wait_time = custom_wait

    @task
    def get_root(self):
        self.client.get("/")

    @task
    def get_item(self):
        self.client.get("/items/99?q=custom")


Full Test Example

Combining all the above elements, here’s a complete Locust test for your FastAPI app.


from locust import HttpUser, task, between
import random

# Custom wait time function
def custom_wait():
    return max(1, random.uniform(1, 3))  # Random wait time between 1 and 3 seconds

class FastAPIUser(HttpUser):
    wait_time = custom_wait  # Use the custom wait time

    @task(3)
    def browse_homepage(self):
        """Simulates browsing the root endpoint."""
        self.client.get("/")

    @task(1)
    def browse_item(self):
        """Simulates fetching an item with ID and query parameter."""
        item_id = random.randint(1, 100)
        self.client.get(f"/items/{item_id}?q=test")

Running Locust for FastAPI

  1. Run Your FastAPI App
    Save the FastAPI app code in a file (e.g., main.py) and start the server

uvicorn main:app --reload

By default, the app will run on http://127.0.0.1:8000.

2. Run Locust
Save the Locust file as locustfile.py and start Locust.


locust -f locustfile.py

3. Configure Locust
Open http://localhost:8089 in your browser and enter:

  • Host: http://127.0.0.1:8000
  • Number of users and spawn rate based on your testing requirements.

4. Run in Headless Mode (Optional)
Use the following command to run Locust in headless mode


locust -f locustfile.py --headless -u 50 -r 10 --host http://127.0.0.1:8000`

-u 50: Simulate 50 users.

-r 10: Spawn 10 users per second.

Postgres – Write-Ahead Logging (WAL) in PostgreSQL

Write-Ahead Logging (WAL) is a fundamental feature of PostgreSQL, ensuring data integrity and facilitating critical functionalities like crash recovery, replication, and backup.

This series of experimentation explores WAL in detail, its importance, how it works, and provides examples to demonstrate its usage.

What is Write-Ahead Logging (WAL)?

WAL is a logging mechanism where changes to the database are first written to a log file before being applied to the actual data files. This ensures that in case of a crash or unexpected failure, the database can recover and replay these logs to restore its state.

Your question is right !

Why do we need a WAL, when we do a periodic backup ?

Write-Ahead Logging (WAL) is critical even when periodic backups are in place because it complements backups to provide data consistency, durability, and flexibility in the following scenarios.

1. Crash Recovery

  • Why It’s Important: Periodic backups only capture the database state at specific intervals. If a crash occurs after the latest backup, all changes made since that backup would be lost.
  • Role of WAL: WAL ensures that any committed transactions not yet written to data files (due to PostgreSQL’s lazy-writing behavior) are recoverable. During recovery, PostgreSQL replays the WAL logs to restore the database to its last consistent state, bridging the gap between the last checkpoint and the crash.

Example:

  • Backup Taken: At 12:00 PM.
  • Crash Occurs: At 1:30 PM.
  • Without WAL: All changes after 12:00 PM are lost.
  • With WAL: All changes up to 1:30 PM are recovered.

2. Point-in-Time Recovery (PITR)

  • Why It’s Important: Periodic backups restore the database to the exact time of the backup. However, this may not be sufficient if you need to recover to a specific point, such as just before a mistake (e.g., accidental data deletion).
  • Role of WAL: WAL records every change, enabling you to replay transactions up to a specific time. This allows fine-grained recovery beyond what periodic backups can provide.

Example:

  • Backup Taken: At 12:00 AM.
  • Mistake Made: At 9:45 AM, an important table is accidentally dropped.
  • Without WAL: Restore only to 12:00 AM, losing 9 hours and 45 minutes of data.
  • With WAL: Restore to 9:44 AM, recovering all valid changes except the accidental drop.

3. Replication and High Availability

  • Why It’s Important: In a high-availability setup, replicas must stay synchronized with the primary database to handle failovers. Periodic backups cannot provide real-time synchronization.
  • Role of WAL: WAL enables streaming replication by transmitting logs to replicas, ensuring near real-time synchronization.

Example:

  • A primary database sends WAL logs to replicas as changes occur. If the primary fails, a replica can quickly take over without data loss.

4. Handling Incremental Changes

  • Why It’s Important: Periodic backups store complete snapshots of the database, which can be time-consuming and resource-intensive. They also do not capture intermediate changes.
  • Role of WAL: WAL allows incremental updates by recording only the changes made since the last backup or checkpoint. This is crucial for efficient data recovery and backup optimization.

5. Ensuring Data Durability

  • Why It’s Important: Even during normal operations, a database crash (e.g., power failure) can occur. Without WAL, transactions committed by users but not yet flushed to disk are lost.
  • Role of WAL: WAL ensures durability by logging all changes before acknowledging transaction commits. This guarantees that committed transactions are recoverable even if the system crashes before flushing the changes to data files.

6. Supporting Hot Backups

  • Why It’s Important: For large, active databases, taking a backup while the database is running can result in inconsistent snapshots.
  • Role of WAL: WAL ensures consistency by recording changes that occur during the backup process. When replayed, these logs synchronize the backup, ensuring it is valid and consistent.

7. Debugging and Auditing

  • Why It’s Important: Periodic backups are static snapshots and don’t provide a record of what happened in the database between backups.
  • Role of WAL: WAL contains a sequential record of all database modifications, which can help in debugging issues or auditing transactions.
FeaturePeriodic BackupsWrite-Ahead Logging
Crash RecoveryLimited to the last backupEnsures full recovery to the crash point
Point-in-Time RecoveryRestores only to the backup timeAllows recovery to any specific point
ReplicationNot supportedEnables real-time replication
EfficiencyFull snapshotIncremental changes
DurabilityRelies on backup frequencyGuarantees transaction durability

In upcoming sessions, we will all experiment each one of the failure scenarios for understanding.

POC : Tamil Date parser using parse

Tamil Date time parser POC
https://github.com/r1chardj0n3s/parse

it requires external dependency parse for parsing the python string format with placeholders

import parse
from date import TA_MONTHS
from date import datetime
//POC of tamil date time parser
def strptime(format='{month}, {date} {year}',date_string ="நவம்பர், 16 2024"):        
    parsed = parse.parse(format,date_string)
    month = TA_MONTHS.index(parsed['month'])+1
    date = int(parsed['date'])
    year = int(parsed['year'])
    return datetime(year,month,date)

print(strptime("{date}-{month}-{year}","16-நவம்பர்-2024"))
#dt = datetime(2024,11,16);
# print(dt.strptime_ta("நவம்பர் , 16 2024","%m %d %Y"))

Locust EP 1 : Load Testing: Ensuring Application Reliability with Real-Time Examples and Metrics

In today’s fast-paced digital application, delivering a reliable and scalable application is key to providing a positive user experience.

One of the most effective ways to guarantee this is through load testing. This post will walk you through the fundamentals of load testing, real-time examples of its application, and crucial metrics to watch for.

What is Load Testing?

Load testing is a type of performance testing that simulates real-world usage of an application. By applying load to a system, testers observe how it behaves under peak and normal conditions. The primary goal is to identify any performance bottlenecks, ensure the system can handle expected user traffic, and maintain optimal performance.

Load testing answers these critical questions:

  • Can the application handle the expected user load?
  • How does performance degrade as the load increases?
  • What is the system’s breaking point?

Why is Load Testing Important?

Without load testing, applications are vulnerable to crashes, slow response times, and unavailability, all of which can lead to a poor user experience, lost revenue, and brand damage. Proactive load testing allows teams to address issues before they impact end-users.

Real-Time Load Testing Examples

Let’s explore some real-world examples that demonstrate the importance of load testing.

Example 1: E-commerce Website During a Sale Event

An online retailer preparing for a Black Friday sale knows that traffic will spike. They conduct load testing to simulate thousands of users browsing, adding items to their cart, and checking out simultaneously. By analyzing the system’s response under these conditions, the retailer can identify weak points in the checkout process or database and make necessary optimizations.

Example 2: Video Streaming Platform Launch

A new streaming platform is preparing for launch, expecting millions of users. Through load testing, the team simulates high traffic, testing how well video streaming performs under maximum user load. This testing also helps check if CDN (Content Delivery Network) configurations are optimized for global access, ensuring minimal buffering and downtime during peak hours.

Example 3: Financial Services Platform During Market Hours

A trading platform experiences intense usage during market open and close hours. Load testing helps simulate these peak times, ensuring that real-time data updates, transactions, and account management work flawlessly. Testing for these scenarios helps avoid issues like slow trade executions and platform unavailability during critical trading periods.

Key Metrics to Monitor in Load Testing

Understanding key metrics is essential for interpreting load test results. Here are some critical metrics to focus on:

1. Response Time

  • Definition: The time taken by the system to respond to a request.
  • Why It Matters: Slow response times can frustrate users and indicate bottlenecks.
  • Example Thresholds: For websites, a response time below 2 seconds is considered acceptable.

2. Throughput

  • Definition: The number of requests processed per second.
  • Why It Matters: Throughput indicates how many concurrent users your application can handle.
  • Real-Time Use Case: In our e-commerce example, the retailer would track throughput to ensure the checkout process doesn’t become a bottleneck.

3. Error Rate

  • Definition: The percentage of failed requests out of total requests.
  • Why It Matters: A high error rate could indicate application instability under load.
  • Real-Time Use Case: The trading platform monitors the error rate during market close, ensuring the system doesn’t throw errors under peak trading load.

4. CPU and Memory Utilization

  • Definition: The percentage of CPU and memory resources used during the load test.
  • Why It Matters: High CPU or memory utilization can signal that the server may not handle additional load.
  • Real-Time Use Case: The video streaming platform tracks memory usage to prevent lag or interruptions in streaming as users increase.

5. Concurrent Users

  • Definition: The number of users active on the application at the same time.
  • Why It Matters: Concurrent users help you understand how much load the system can handle before performance starts degrading.
  • Real-Time Use Case: The retailer tests how many concurrent users can shop simultaneously without crashing the website.

6. Latency

  • Definition: The time it takes for a request to travel from the client to the server and back.
  • Why It Matters: High latency indicates network or processing delays that can slow down the user experience.
  • Real-Time Use Case: For a financial app, reducing latency ensures trades execute in near real-time, which is crucial for users during volatile market conditions.

7. 95th and 99th Percentile Response Times

  • Definition: The time within which 95% or 99% of requests are completed.
  • Why It Matters: These percentiles help identify outliers that may impact user experience.
  • Real-Time Use Case: The streaming service may analyze these percentiles to ensure smooth playback for most users, even under peak loads.

Best Practices for Effective Load Testing

  1. Set Clear Objectives: Define specific goals, such as the expected number of concurrent users or acceptable response times, based on the nature of the application.
  2. Use Realistic Load Scenarios: Create scenarios that mimic actual user behavior, including peak times, user interactions, and geographical diversity.
  3. Analyze Bottlenecks and Optimize: Use test results to identify and address performance bottlenecks, whether in the application code, database queries, or server configurations.
  4. Monitor in Real-Time: Track metrics like response time, throughput, and error rates in real-time to identify issues as they arise during the test.
  5. Repeat and Compare: Conduct multiple load tests to ensure consistent performance over time, especially after any significant update or release.

Load testing is crucial for building a resilient and scalable application. By using real-world scenarios and keeping a close eye on metrics like response time, throughput, and error rates, you can ensure your system performs well under load. Proactive load testing helps to deliver a smooth, reliable experience for users, even during peak times.

How to Create & Publish a PHP Package with Composer? – தமிழில்

அக், 13 2024

பிஹெச்பி பொதிகளை பிஹெச்பி கம்போசர்-உடன் உருவாக்க மற்றும் வெளியிடுவது ஒரு நேரடியான வழிமுறை இந்த வழிமுறையை பின்பற்றினால் நாம் எளிமையாக பிஹெச்பி சமூகத்துடன் நமது நிரல்களை பொதிவடிவத்தில் பகிர்ந்துகொள்ளலாம்.

கம்போசர் – (பிஹெச்பி சார்புகளின் நிர்வாகி) – PHP Dependency Manager

தேவையானவை:

உங்களது கணினியில் பின்வருவற்றை நிறுவி இருப்பது அவசியம்.

  • பிஹெச்பி (பதிப்பு 7.4 or அண்மை)
  • கம்பொசர் (அண்மை பதிப்பு)
  • கிட் (அண்மை பதிப்பு)
  • ஒரு கிட் ஹப் கணக்கு
  • பேக்கஜிஸ்ட் கணக்கு

படிகள்:

படி 1: நம்முடைய பொதிக்கான ஒரு கோப்புறையை உருவாக்கி கொள்ளவும்.

mkdir open-tamil
cd open-tamil

படி 2: கம்போசர் பொதியை துவக்குதல்

நம் கணினியில் கம்போசர் பொதியை துவக்க பின்வரும் கட்டளையை பயன்படுத்தவும்.

composer init

மேற்கண்ட கட்டளையை பயன்படுத்தும் கட்டளைவரி இடைமுகம் பின்வரும் கேள்விகளை கேட்கும்

Package name: your-username/my-php-package

Description: A sample PHP package

Author: Your Name <your-email@example.com>

Minimum Stability: stable (or leave blank)

Package Type: library

License: MIT

இந்த கேள்விகளுக்கு விடையளித்த பின்பு பிறசார்புகளை கேட்கும் no கொடுக்கவும்.

இறுதியாக composer.json உருவாக்க தூண்டியில் yes கொடுத்து உருவாக்கி கொள்ளவும்.

படி 3 :

composer.json கோப்பு உருவாக்கிய பிறகு அது பின்வருமாறு தோன்றும்

{
    "name": "your-username/my-php-package",
    "description": "A sample PHP package",
    "type": "library",
    "require": {
        "php": ">=7.4"
    },
    "autoload": {
        "psr-4": {
            "MyPackage\\": "src/"
        }
    },
    "authors": [
        {
            "name": "Your Name",
            "email": "your-email@example.com"
        }
    ],
    "license": "MIT"
}

படி 4

பின்னர் உங்களது குறிமுறையை கிட் பயன்படுத்தி கிட்ஹப்பில் பதிவேற்றவும்.

படி 5

குறியீட்டை கம்போசரில் பதிப்பிக்க பேக்கேஜிஸ்டில் உள்நுழையவும். பின்னர் submit பொத்தானை அழுத்தவும்

submit பொத்தானை அழுத்தியவுடன் பொதியை எற்றும் பக்கம் திறக்கப்பட்டு உங்களது கிட்ஹப் கணக்கில் உள்ள பொதுவாக அனுமதியில் இருக்ககூடிய ரெபொசிடரியின் வலைமுகவரியை உள்ளிட்டு சரிபார்க்கும் பொத்தானை அழுத்தி சரிபார்த்துகொள்ளவும்.

குறிப்பு : கம்போசரை பொறுத்தவகையில் பதிப்பிப்பவர் வென்டார் (vendor) என்று குறிப்பிடப்படுவர். நான் hariharan என்ற வென்டார் பெயரை பயன்படுத்தி இரு பொதிகளை பதிப்பித்துள்ளேன்.

புதிய பொதியை சரிபார்த்த பின் பொதியானது பதிப்பிக்க தயராகிவிடும்.

பார்க்க :

https://packagist.org/packages/hariharan/open-tamil

https://packagist.org/packages/hariharan/thirukural

நிறுவி பார்க்க:

composer require hariharan/thirukural

composer require hariharan/open-tamil

How to view manually installed packages in ubuntu

Hi all in the blog post we are going to list down the packages we installed manually.

why we need that information?
when we set up a fresh Linux Distro or migrate existing or converting Linux installation into a docker image that will very helpful to us

how we are going to get this thing done?
using the aptitude (high-level package manager command-line interface)

install aptitude first if not present in your system

sudo apt install aptitude 

wait a few seconds to complete installation after completing the installation run the following command to find the manually installed packages after the initial run of the

comm -23 <(aptitude search '~i !~M' -F '%p' | sed "s/ *$//" | sort -u) <(gzip -dc /var/log/installer/initial-status.gz | sed -n 's/^Package: //p' | sort -u)

Image description

Voila we did it!

Ubuntu : SSDல் உபுண்டு 20.04 LTS டூயல் பூட் முறையில் விண்டோசுடன் நிறுவுதல்

அக் 31, 2024

அண்மையில் நான் டூயல் பூட் முறையில் விண்டோசுடன் நிறுவிய அனுபவத்தினை இந்த பதிவில் காணலாம்.

நான் SSDல் விண்டோஸ் இயங்குதளம் பயன்படுத்திவருகிறேன். என்னுடைய இன்னொரு HDDல் உபுன்டு இயங்குதளம் வைத்திருக்கிறேன். அந்த வன்வட்டு பழுதடையும் தருவாயில் இருப்பதால் SSDல் உபுண்டு இயங்குதளம் நிறுவ தயாரானேன்.

எப்பொழுதும் புதிய இயங்குதளம் நிறுவ தாயராகும் போது காப்பு பிரதி(Backup) எடுத்துவைத்து தயாராகவும்.

குறிப்பு : நான் இயங்குதளம் 3 முறை நிறுவியுள்ள அனுபவத்தில் காப்பு பிரதி எடுக்காமல் தொடங்கினேன். ஆனால் இவ்வாறு செய்வது பரிந்துரைக்கபடவில்லை.

நான் லைவ் USB ventoy எனும் மென்பொருளின் உதவியுடன் தயார் செய்தேன்.

References :

Setting UP ubuntu’s GRUB as primary bootloader using efibootmgr https://superuser.com/questions/1247300/how-to-make-uefi-bios-start-grub-not-windows

Ubuntu : சும்மா இருந்ததால் வந்த சிக்கல்

அக், 17 2024

இரவு ஒரு 10: 35 மணி இருக்கும் கணினியை திறந்து லாகின் செய்து விட்டு குரோமியம் உலவியில் தமிழ் லினக்ஸ் பாரத்தில் போட்ட கேள்விக்கு பதில் வந்ததா என்று பார்த்துக்கொண்டிருந்தேன்.

பார்த்துகொண்டிருக்கும் போது ஜேசன் அவர்களின் பதிவு தந்தி(Telegram App)யில் வந்தது. அதில் A2D நந்தா அவர்களின் CDK Offers மற்றும் CDKLabs பற்றிய சில செய்திகள் வந்தது. அவற்றையெல்லம் பார்த்துவிட்டு கணினியில் சுட்டியை சொடுக்கினேன் செய்தேன். எதற்கும் ஒத்துழைக்க வில்லை ஆனால் சுட்டி மட்டும் நகர்ந்தது. விசைப்பலகையை தட்டி டெர்மினலில் எதேனும் கட்டளைகளை பயன்படுத்தி குரோமியத்தினை நிறுத்திவிட்டு மீள் தொடங்கலாம் என நினைத்தேன். ஆனால் விசைகள் இயங்கின அதனுடைய உள்ளீட்டை கணிணி ஏற்கவில்லை.

திறன்பேசியில் தேடினேன்.

ரெடிட்டில் ஒரு பதிவு கிடைத்தது. அதில் குறிப்பிட்ட படி ctrl+alt+F3 யை அழுத்தினேன். பின்னர்

sudo systemctl status gdm 

கட்டளையிட்டேன் (inactive) நிலையில் இருந்தது. பின்னர் நான் lightdm பயன்படுத்துவதால் அதனுய நிலையை சரிபார்த்தேன்.

sudo systemctl status lightdm

அது இயக்கத்தில் இருந்தது. lightdm ஐ மீள்தொடக்கம் செய்தேன். பின்வரும் கட்டளை கொண்டு

sudo systemctl restart lightdm

மீள் தொடக்கம் செய்ததும் விசைப்பலகை சரியாக இயங்கியது. சுட்டியும் நன்றாக இயங்கியது.

நன்றாக இயங்கியதால் இந்த பதிவையும் எழுத முடிந்தது.

நன்றி.

https://www.redit.com/r/Ubuntu/comments/133js51/unable_to_click_in_but_mouse_moves_ubuntu/

ரெடிட் பதிவு

Kanchilug Monthly Meet – Oct ,13 2024

Lightning Talk by Krishna

Topic : Desktop Customization : picom, pywal

Resource : Krishna S

SSD File System Comparison : https://www.linux.org/threads/comparison-of-file-systems-for-an-ssd.28780/

https://etherpad.wikimedia.org/p/KanchiLUGMMOct13

Notes on Choosing HDD to SSD Linux Installation migration

Chat GPT Prompt : how to backup current linux installation configuration files and packages list as a archive and apply on a new installation

Result

Backing up your current Linux installation’s configuration files and package lists is a great way to ensure you can easily restore or replicate your setup on a new installation. Here’s how you can do it:

Step 1: Backup Configuration Files

  1. Identify Configuration Files: Most configuration files are located in /etc. You may also have application-specific configurations in your home directory (like .bashrc, .vimrc, etc.).
  2. Create an Archive:
    You can create a compressed archive (like a tarball) of your configuration files. Run the following command:
   sudo tar -czvf config_backup.tar.gz /etc /home/your_username/.bashrc /home/your_username/.vimrc

Adjust the paths based on what configuration files you want to back up.

Step 2: Backup Installed Packages List

The method to back up the installed package list depends on your Linux distribution.

For Debian-based systems (like Ubuntu):

  1. Backup Installed Packages:
   dpkg --get-selections > package_list.txt
  1. Backup Sources List:
   sudo cp /etc/apt/sources.list /etc/apt/sources.list.backup

For Red Hat-based systems (like Fedora, CentOS):

  1. Backup Installed Packages:
   rpm -qa > package_list.txt
  1. Backup Repositories:
   sudo cp -r /etc/yum.repos.d/ /path/to/backup/repo_backup/

Step 3: Create a Complete Backup Archive

Combine everything into one archive:

tar -czvf full_backup.tar.gz config_backup.tar.gz package_list.txt /etc/apt/sources.list.backup

Step 4: Restore on a New Installation

  1. Transfer the Backup: Copy the full_backup.tar.gz to your new installation.
  2. Extract the Backup:
   tar -xzvf full_backup.tar.gz
  1. Restore Configuration Files:
   sudo tar -xzvf config_backup.tar.gz -C /
  1. Restore Package List: For Debian-based systems:
   sudo dpkg --set-selections < package_list.txt
   sudo apt-get dselect-upgrade

#### For Red Hat-based systems:
You can reinstall packages from the list:

   xargs -a package_list.txt sudo dnf install -y
  1. Restore Sources List (Debian-based):
   sudo cp /etc/apt/sources.list.backup /etc/apt/sources.list
   sudo apt update

Step 5: Finalize and Reboot

After restoring everything, it’s a good idea to reboot your system to ensure all configurations take effect.

Notes:

  • Make sure to review any new configurations or installed packages after the restoration, as dependencies and versions may vary.
  • For user-specific configurations, you may want to back up the entire home directory or specific application directories.

This process should help you smoothly transition to a new Linux installation with your desired configurations and packages!

Chat GPT Prompt : I am in a plan of migrating linux os to a new file system which is xfs or zfs brtfs which on is good

Choosing between XFS, ZFS, and Btrfs depends on your specific needs and use cases. Here’s a breakdown of each file system’s strengths and considerations to help you decide:

XFS

Pros:

  • Performance: Excellent performance, especially for large files and high-performance workloads.
  • Scalability: Designed for scalability, making it suitable for high-capacity storage systems.
  • Mature: A well-established file system with a long history of stability.

Cons:

  • Features: Lacks some advanced features like snapshots and built-in RAID compared to ZFS and Btrfs.
  • Management: Does not have as many management tools as ZFS.

ZFS

Pros:

  • Data Integrity: Strong focus on data integrity with built-in checksumming.
  • Snapshots and Clones: Supports efficient snapshots and clones, allowing for easy backups and recovery.
  • Compression: Offers built-in compression options, which can save space.
  • RAID: Supports various RAID levels natively (ZRAID), enhancing redundancy.

Cons:

  • Memory Usage: Can require more RAM for optimal performance.
  • Complexity: More complex to set up and manage compared to traditional file systems.

Btrfs

Pros:

  • Snapshots and Subvolumes: Supports snapshots and subvolumes, making it flexible for backups and system management.
  • Built-in RAID: Offers support for multiple RAID levels.
  • Compression and Deduplication: Supports on-the-fly compression and deduplication.

Cons:

  • Stability: Still considered less mature than XFS and ZFS; while it has improved significantly, it may not be as stable for all workloads.
  • Performance: Can have variable performance depending on the workload and configuration.

Recommendations

  • For General Use: If you want stability and performance for general workloads, XFS is a great choice.
  • For Data Integrity and Advanced Features: If data integrity, snapshots, and advanced features are critical, ZFS is likely the best option.
  • For Flexibility and Modern Features: If you want modern features like snapshots and subvolumes with some flexibility, consider Btrfs.

Final Thoughts

Evaluate your specific use cases (e.g., data integrity, performance, ease of management) and the resources available on your system (e.g., RAM for ZFS). If possible, testing each file system in a non-production environment can also help you determine which one best meets your needs.

Top Data quality tools

Image descriptionTop 10 Data Quality Tools

⎯⎯⎯⎯⎯⎯⎯⎯⎯  
⎯⎯⎯Source From @ Deepak Bhardwaj ⎯⎯⎯⎯⎯

➤ 𝐀𝐛 𝐈𝐧𝐢𝐭𝐢𝐨
↳ Comprehensive data management with advanced data quality features.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Automated data analysis, rule definition, issue ticketing, centralised control.

➤ 𝐒𝐀𝐒 𝐃𝐚𝐭𝐚 𝐐𝐮𝐚𝐥𝐢𝐭𝐲
↳ Enhances data accuracy, consistency, and completeness with comprehensive tools.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Data profiling, duplicate merging, standardisation, SAS Quality Knowledge Base.

➤ 𝐃𝐐𝐋𝐚𝐛𝐬 𝐏𝐥𝐚𝐭𝐟𝐨𝐫𝐦
↳ Holistic data quality and observability tool using AI and machine learning.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Automated data profiling, anomaly detection, proactive monitoring.

➤ 𝐎𝐩𝐞𝐧𝐑𝐞𝐟𝐢𝐧𝐞
↳ A free, open-source tool for cleaning and transforming messy data.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Data consistency, error correction, versatile data transformations.

➤ 𝐏𝐫𝐞𝐜𝐢𝐬𝐞𝐥𝐲 𝐃𝐚𝐭𝐚 𝐈𝐧𝐭𝐞𝐠𝐫𝐢𝐭𝐲 𝐒𝐮𝐢𝐭𝐞
↳ A modular suite provides data quality, governance, and mastering.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Profiling, cleansing, standardisation, real-time data visualisation.

➤ 𝐎𝐫𝐚𝐜𝐥𝐞 𝐄𝐧𝐭𝐞𝐫𝐩𝐫𝐢𝐬𝐞 𝐃𝐚𝐭𝐚 𝐐𝐮𝐚𝐥𝐢𝐭𝐲
↳ Comprehensive solution for data governance and quality management.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Data profiling, extensible features, batch and real-time processing.

➤ 𝐓𝐚𝐥𝐞𝐧𝐝 𝐃𝐚𝐭𝐚 𝐅𝐚𝐛𝐫𝐢𝐜
↳ Unified platform for data integration and quality management.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Data profiling, cleansing, integration, real-time monitoring.

➤ 𝐒𝐀𝐏 𝐃𝐚𝐭𝐚 𝐒𝐞𝐫𝐯𝐢𝐜𝐞𝐬
↳ Advanced tool for data integration and quality across diverse sources.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Data transformation, cleansing, profiling, integration with SAP systems.

➤ 𝐀𝐭𝐚𝐜𝐜𝐚𝐦𝐚 𝐎𝐍𝐄
↳ An AI-powered platform integrating data governance, quality, and master data management.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Data profiling, real-time monitoring, integrated data catalog.

➤ 𝐈𝐧𝐟𝐨𝐫𝐦𝐚𝐭𝐢𝐜𝐚 𝐂𝐥𝐨𝐮𝐝 𝐃𝐚𝐭𝐚 𝐐𝐮𝐚𝐥𝐢𝐭𝐲
↳ AI-driven data quality solution for cloud and hybrid environments.
↳ 𝐊𝐞𝐲 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Data profiling, cleansing, automated anomaly detection, CLAIRE engine.

Cheers!
Deepak Bhardwaj

Keyboard Tamil99 :தேடிய விசைப்பலகை பயிற்சி வலைதளம் கிடைத்தது.

அக் 5, 2024

தமிழில் தட்டச்சு செய்ய தமிழ்99 விசைப்பலகை பயன்படுத்த மிகவும் எளிதாக இருக்கும். முதலில் இருந்தே எகலப்பை மற்றும் தமிழ் பொனெட்டிக்(ஒலிப்பு) விசைப்பலகையில் தமிழில் தட்டச்சு செய்ய பழகிய என்னை போன்றவர்களுக்கு தமிழ் தட்டச்சு செய்ய தமிழ்99 விசைப்பலகை பயிற்சி எடுக்க மிகவும் கடினமாக இருக்கிறது.

ஆகவே இந்த சிக்கலை தீர்க்க எதேனும் வலைதளங்கள் இருக்கின்றனவா என தேடிய பொழுது கிடைத்த ஒர் வலைதளம்.

https://wk.w3tamil.com/

இந்த வலைதளத்தில் தமிழ்99 விசைப்பலகையை பயிற்சி பெற 3 வித அமைப்புகள் உள்ளன.

முதல் அமைப்பு தமிழ்99 விசைப்பலகை மட்டும் வைத்துகொள்வது. இதில் வடமொழி மற்றும் ஆங்கில எழுத்துகள் இருக்காது.

இரண்டாம் அமைப்பு தமிழ்99 விசைப்பலகை வடமொழி எழுத்துகள் உடன் ஆங்கில எழுத்துகளும் லேசான நிறத்தில் தோன்றும் வடமொழி எழுத்துகளை தட்டச்சு செய்ய {shift} விசையை பயன்படுத்தவும்.

மூன்றாம் அமைப்பு தமிழ்99 விசைப்பலகை வடமொழி எழுத்துகள் உடன் ஆங்கில எழுத்துகளும் அடர் நிறத்தில் தோன்றும் .

தொடக்க பயனர்கள் மூன்றாம் அமைப்பை பயன்படுத்தலாம் எளிமையாக ஆங்கில எழுத்துக்களின் விசையை பயன்படுத்தி பழகலாம் பின்னர் நன்கு பயிற்சி பெற்றபின் முதலாம் அமைப்பிற்கு வரலாம்.

வாங்க பழகலாம் தமிழ்99!

How to Deploy a Laravel application in Shared Hosting

Preparing Hosting Infrastructure for Deployment:

  1. Create a subdomain or main domain
  2. login into public_html folder of the site or subdomain
  3. put a index.html file and check if the sub domain is working

Laravel Project Upload :

  1. Prepare a Zip Archive of the Laravel Project
  2. Create a folder into server and extract your project into public_html folder created earlier
  3. Then change the public folder content to the public_html folder and change the bootstrap and other paths in index as per need
  4. After that you’re going to check

Ubuntu : How to make partitions mount at startup -தமிழில்

அக் 01, 2024

உபுண்டு இயக்கமுறையில் வன்வட்டு மற்றும் திடநிலைவட்டினை இயங்குதளத்தின் தொடக்கத்தில் இணைப்பது எவ்வாறு என்பதனை இக்கட்டுரையில் காண்போம்.

பயனர் இடைமுக வழி (புதிய பயனர்களுக்கு) : வட்டுகள் (Disks) எனும் பயன்பாடானது தானமைவாகவே

/etc/fstab

கோப்பினை நமக்காக திருத்தி நமது தேவைக்கு ஏற்றார்போல மாற்றிக்கொள்ள வழிவகை செய்கிறது (இயங்குதளத்தினை உடைக்காமல்).

வட்டுகள் (Disks) பயன்பாட்டினை பயன்பாட்டு ஏவி (launcher) துணைகொண்டு இயக்க (disks) என பயன்பாட்டு ஏவியில் தேடவும்.

மேற்கண்ட துவக்கபட்டியில் காட்டபட்டுள்ளது போல வட்டுக்கள்(Disks) பயன்பாடு தோன்றும். அந்தப் பயன்பாட்டினை திறக்கையில் கீழே காட்டபட்டுள்ளது போல பட்டியலிடப்பட்டு வன்வட்டுக்களும் திடநிலை வட்டுக்களும் தோன்றும்.

நான் இரண்டாவது வன்வட்டினை சொடுக்குகையில் அதில் உள்ள வன்வட்டின் பகுதிகள் (Partitions) திரையில் காட்டப்படும்.

அதில் நாம் தானமைவாக இணையக்கூடிய அமைப்பை கட்டமைக்க அந்த வட்டினை தேர்வு செய்து இணைக்கவேண்டிய பகுதியையும் தெரிவு செய்துகொள்ளவேண்டும்.

அப்போது வன்வட்டின் பகுதிகளின் கீழ் ஒரு மூன்று தேர்வுகள் தோன்றும்.

முதல் தேர்வு – இயங்குதளத்தில் இணை (Mount)

இரண்டாம் தேர்வு – பகுதியை நீக்கு (Delete Partition) (தேர்வினை தேர்வுசெய்துவிடாதீர்கள் வன்வட்டின் அந்தபகுதியில் உள்ள தரவுகள் அனைத்தும் நீக்கப்பட்டு ஒதுக்கப்படாத நினைவிடமாக மாற்றப்பபட்டுவிடும்)

மூன்றாம் தேர்வு – பிற அமைப்புகளை இந்த தெரிவில் காணலாம்.

மூன்றாவது தேர்வினை சொடுக்கினால் ஒரு சுறுக்குப்பட்டி(Context Menu) விரியும் அதில் இணைக்கும் தெரிவுகளை திருத்து (Edit Mount Options) எனும் தொடுப்பை அழுத்தினால் இணைக்கும் தெரிவுகள் உரையாடல் பெட்டி(Dialog Box) தோன்றும்.

இணைக்கும் தெரிவுகள் உரையாடல் பெட்டியில் இருப்பவை எல்லாம் பயன்படுத்தா இயலா நிலையில் (grayed out) காட்சியளிக்கும்.

இதனைப் பயன்படுத்தும் நிலைக்கு கொணற பயனை அமர்வு இயல்புநிலை (User Session Default) அமைப்புகளை மாற்று பொத்தான் (toggle button) பயன்படுத்தி மாற்றும் போது எல்லா அமைப்புகளும் திருத்தகக் கூடிய நிலையில் மாறிவிடும். பின்னர் அதனை சேமித்தால் அந்த வன்வட்டின் பகுதி தானமைவாகவே இயங்குதளத்தின் தொடக்கத்தில் இணைக்கப்பட்டுவிடும்.

நன்றி

அடுக்கு பரிமாற்றம் (stack exchange) : https://askubuntu.com/questions/164926/how-to-make-partitions-mount-at-startup

முனையத்தில் பகுதிகளை இணைக்கும் வழிமுறையை மற்றொரு பதிவில் காணலாம்.

Docker : Creating and uploading docker image to docker hub – டாக்கர் படத்தை உருவாக்கி அதை டாக்கர் ஹப்பில் பதிவேற்றுதல்

செப் 25, 2024

நான் டாக்கர் வகுப்பில் கற்றவற்றை வைத்து ஒரு டாக்கர் படத்தை டாக்கர் ஹப்பில் பதிவேற்றுதல் வரை நடந்த செயல்பாடுகளை இந்தப்பதிவில் குறிப்பிடுகிறேன்.

டாக்கர் ஹப் கணக்கை துவக்குதல்

https://app.docker.com/signup இணைப்பை சொடுக்கவும் அதில் கூகுள் கணக்கை வைத்து (நீங்கள் பிற உள்நுழைவு அமைப்புகளையும் பயன்படுத்திக் கொள்ளலாம்) உள்நுழையவும்.

வெற்றிகரமான உள்நுழைவுக்கு பிறகு https://hub.docker.com க்கு Docker Hub Link ஐ சொடுக்குவதுமூலம் செல்லவும்.

Click the Docker Hub Link

டாக்கர் ஹப்பில் நாம் படத்தை பதிவேற்றம் செய்யும் முன்னர் அதனை பதிவேற்ற ஒரு கோப்புறை ஒன்றை உருவாக்க வேண்டும்.

கோப்புறைஐ உருவாக்கிய பிறகு நாம் நமது கணினியில் டாக்கர் படத்தை உருவாக்கிய பின்னர் அதனை பதிவேற்றிக்கொள்ளலாம்.

கணிணியில் ஒரு டாக்கர் படத்தை உருவாக்குதல்

முதலில் டாக்கர் படத்தை உருவாக்கும் முன்னர் பழைய டாக்கர் கலன்களின் (Container) இயக்கத்தை நிறுத்திவிட்டு சற்று நினைவத்தினை தயார் செய்து கொள்கிறேன் (நினைவக பற்றாக்குறை இருப்பதால்).

docker rm $(docker ps -aq)

பின்னர் Dockerfile எழுத துவங்க வேண்டியதுதான்

டாக்கர் படத்தை உருவாக்க நமக்கு தேவயான சார்பு படங்களை முதலில் பதிவிறக்கி அதனை தயார்படுத்திக்கொள்வோம்.

என்னுடய டாக்கர் படம் மிகவும் சிறியதாக வேண்டும் என நினைப்பதால் நான் python3-alpine பயன்படுத்துகிறேன்.

https://hub.docker.com/r/activestate/python3-alpine

நிறுவல் சரிபார்த்தல்

மேற்கண்ட கட்டளைவரிகளை பயன்படுத்தி நாம் நமது நிறுவலை சரிபார்க்கலாம்.

டாக்கர் கோப்பை எழுதுதல் மற்றும் டாக்கர் படத்தை உருவாக்குதல்

# we are choosing the base image as python alpine
FROM activestate/python3-alpine:latest
# setting work directory
WORKDIR ./foss-event-aggregator
# Copying the workdirectory files to the container 
COPY ./foss-event-aggregator ./foss-event-aggregator
# Installing required dev-dependencies 
# RUN ["pip3","install","-r","./foss-event-aggregator/dev-requirements.txt"]
# Running PIP commands to update the dependencies for the
RUN ["apk","add","libxml2-dev","libxslt-dev","python-dev"]

RUN ["pip3","install","-r","./foss-event-aggregator/requirements.txt"]

CMD ["python","eventgator.py"]

டாக்கர் கோப்பு எழுதும் போது தேவையான சார்புகள் அனைத்தும் சரியாக நிறுவப்படுகிறதா என்பதை சரிபார்க்க பிழைச்செய்தி வரும்போது அதனை சரிசெய்ய டாக்கர் கோப்பை தேவைப்படி மாற்றுக.

வெற்றிகரமாக foss-event-aggregator எனும் டாக்கர் படம் உருவாக்கப்பட்டது.

உருவாக்கப்பட்ட படத்தை பரிசோதித்தாகிவிட்டது இப்பொழுது டாக்கர் ஹப்புக்கு பதிவேற்றலாம்.

டாக்கர் ஹப்புக்கு பதிவேற்றுதல்

படத்தை பரிசோதித்த பிறகு கோப்புறை பெயரில் டாக் செய்யவேண்டும்

docker image tag foss-event-aggregator:v1 itzmrevil/foss-events-aggregator:v1

டாக் செய்யபட்ட பிறகு டாக்கரில் CLIல் உள்நுழைவு செய்து டாக்கரில் பதிவேற்றம் செய்தால் மட்டுமே டாக்கர் ஏற்றுக்கொள்ளும்.

டாக்கரில் உள்நுழைய

docker login

கொடுத்து டெர்மினலில் வரும் படிகளை பின்பற்றவும்.

உள்நுழைவு செய்த பின்னர்

docker push itzmrevil/foss-events-aggregator:v1

கட்டளையை கொடுத்து டாக்கர் படத்தை பதிவேற்றவும்

பதிவேற்றம் செய்யபட்டதை டாக்கர் ஹப்பில் பார்க்க https://hub.docker.com/repository/docker/itzmrevil/foss-events-aggregator/general

வெற்றி ! வெற்றி !! வெற்றி !!!

Docker : Virtual Machines – மெய்நிகர் இயந்திரங்கள்

செப் 25, 2024

ஒரு கணிணியில் ஒரு வலைப்பயன்பாடினை இயங்குவதற்கு 4 பயன்பாடுகள் பயன்படுத்த வேண்டுமெனில் அந்த பயன்பாடு இயக்கத்திற்காக சார்ந்திருக்கும் நுண்செயலி(CPU), நினைவகம்(RAM), சேமிப்பக (Storage) போன்ற வன்பொருள் தேவைகளை பூர்த்தி செய்ய வேண்டும்.

இதே தேவைகளை சில சமயங்களில் பயனர்களின் (Users) எண்ணிக்கைக்கு ஏற்றவாறும் பயன்பாட்டின் அளவுகளுக்கு (Usage) ஏற்றவாறு நாம் அதிகப்படுத்த (Scaling) வேண்டியுமுள்ளது.

ஓரே கணிணியில் அதிகளவு பயனர்களின் அணுகல்களை அனுமதித்தால் அதிகபயன்பாட்டின் காரணமாக வலைதளங்கள் முடங்கும் அபாயம் உள்ளது.இதனை தவிர்க்க தனித்தனி இயந்திரங்களை பயன்படுத்தும் போது தேவைக்கு அதிகமாக வன்பொருள் மீதமிருக்கும் அது முழுவதுமாக பயன்படுத்தப் படாமலும் இருக்கும் (proper utilisation).

எடுத்துக்காட்டாக கீழ்வரும் 4 பயன்பாடுகளை

  • அப்பாச்சி வலை சேவையகம்
  • கிராப் கிகுவெல் எந்திரம்
  • போஸ்டுகிறீஸ் தரவுதள அமைப்பு
  • எக்ஸ்பிரஸ் வலைச் சேவையகம்

ஒரு கணிணியில் இயக்குவற்கு 4 GB (RAM), 2 Core (CPU) மற்றும் 250 GB (Storage) தேவைப்படும் என வைத்துக்கொள்வோம்.

நம்மிடம் 16 GB (RAM), 16 Core (CPU) மற்றும் 1000 GB கொண்ட கணினி உள்ளது அதில் இரண்டு நிறுவல்களை அமைத்து சோதணை செய்து பார்க்க மெய்நிகர் இயந்திரங்கள் கருத்துரு வழிவகை செய்கிறது.

ஆகவே ஒரு கணினியில் வன்பொருள் அமைப்புகளை தேவைகளைப் பொறுத்து ஒரு கணினியை பல கணினிகளாக மாற்றி சோதனை செய்து பயன்படுத்தும்போது அந்த கணிணிகளை மெய்நிகர் இயந்திரங்கள் எனப் பொருள் கொள்ளலாம்.

❌