DEV Community: Nitin Garg

Design pattern using c#

Nitin Garg — Thu, 24 Aug 2023 14:05:36 +0000

Design patterns are reusable solutions to common problems that occur during software design and development. They are like templates or blueprints that provide a structured way to solve recurring design challenges in a software application. These patterns are not specific to a particular programming language or technology; instead, they offer general guidelines and best practices for designing robust, maintainable, and efficient software.

There are mainly 3 categories of design patterns introduced by the "Gang of Four" (GoF) in their book "Design Patterns: Elements of Reusable Object-Oriented Software." explained below:

Creational Patterns: These patterns deal with object creation mechanisms, abstracting the instantiation process.

Structural Patterns: These patterns focus on how objects are composed or structured to form larger, more complex structures.

Behavioral Patterns: These patterns are concerned with how objects interact and communicate with one another.

How to create Memory Dumps for dotnet applications in Linux?

Nitin Garg — Mon, 10 Jul 2023 00:19:23 +0000

Memory dumps are invaluable diagnostic tools for analyzing system performance and identifying memory leaks. In this blog post, we will walk you through the process of creating memory dumps on Linux machines, specifically focusing on dotnet applications. Additionally, we'll explore how to transfer the memory dump to your local Windows machine and perform analysis using the dot memory tool. Let's dive in!

Creating Memory Dump on Linux for dotnet application:
To begin, we need to install the necessary diagnostic tools. Follow these steps:

Login to the Linux machine using SSH.
Run the following commands to install the diagnostic tools:

sudo apt update 
sudo apt install wget
sudo wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb 
sudo dpkg -i packages-microsoft-prod.deb 
sudo apt update
sudo apt install apt-transport-https 
sudo apt install dotnet-sdk-6.0 -y
sudo dotnet --version
sudo dotnet tool install --tool-path /tools dotnet-trace
sudo dotnet tool install --tool-path /tools dotnet-counters
sudo dotnet tool install --tool-path /tools dotnet-dump

Once the tools are installed, navigate to the /tools directory and verify the installation by running:

cd /tools
./dotnet-dump --help

Identify the process for which you want to create a memory dump. Execute the following command to find the process ID:

ps aux

Finally, create the memory dump using the dotnet-dump tool:

./dotnet-dump collect -p <pid> -o <dump_file_path>

Replace <pid> with the process ID and with the desired path to save the memory dump.

Transferring the Memory Dump to your Local Machine:
Once you have the memory dump file on the Linux machine, follow these steps to transfer it to your local Windows machine:

Open Git Bash or a command prompt on your local machine.
Use the scp command to copy the memory dump snapshot from the remote Linux machine to your local Windows machine:

scp -r remote_vm_username@remote_vm_ip_address:remote_path_for_dump_snapshot local_path_for_dump_snapshot
#Example
scp -r user1@60.60.100.100:/home/user1/dump_2023_21 /c/dumps

Analyzing the Memory Dump using dot memory tool:
To analyze the memory dump on your local Windows machine, follow these steps:

Install the dot-memory tool on your Windows machine.
Launch the dot-memory tool.
Import the Process Dump snapshot obtained from the memory dump you transferred earlier.
Explore the various analysis features and tools provided by dot-memory to identify and analyze memory leaks effectively.

Conclusion:
Memory dumps are indispensable when it comes to diagnosing system performance issues and memory leaks. In this blog post, we discussed the step-by-step process of creating memory dumps on Linux machines for dotnet applications. We also covered the procedure for transferring the memory dump snapshot to your local Windows machine and using the dot memory tool to perform analysis. By following these guidelines, you can effectively investigate and resolve memory-related issues in your Linux environment.

How to create free certificate with Let's Encrypt?

Nitin Garg — Sun, 09 Jul 2023 10:09:13 +0000

Securing your web applications and websites with valid SSL/TLS certificates is essential for ensuring the privacy and security of user data. Let's Encrypt, a free and open certificate authority, provides an easy and automated way to obtain and manage SSL/TLS certificates. In this blog post, we will guide you through the process of creating a DNS validation server certificate using Let's Encrypt and Certbot.

Step 1: Add an A Record
Before obtaining a certificate, you need to have a root domain (e.g, mydomain.com) registered. Choose a DNS registrar and log in to your account. Create an A record for the application under your domain (e.g., myapp.mydomain.com).

Step 2: Install Certbot
Certbot is a popular Let's Encrypt client developed by the Electronic Frontier Foundation (EFF). It simplifies the process of obtaining and managing certificates. Install Certbot on your server by following these steps:

sudo apt-get update
sudo snap install core; sudo snap refresh core
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot
sudo certbot --version

Step 3: Create Certificates
Certbot provides various methods for domain validation and certificate retrieval. We will use Certbot's standalone mode, which runs a built-in web server to handle the validation process. Follow these steps to obtain your certificate:

Make sure port 80 is open in your firewall to allow Let's Encrypt to verify your domain:

sudo ufw allow 80

Run the following Certbot command to obtain the certificate:

sudo certbot certonly --standalone --preferred-challenges http -d [domain-name]

Replace [domain-name] with your domain name (e.g., myapp.mydomain.com).

Note: By default, certbot creates all relevant certs files under /etc/letsencrypt/live/[domain-name]

Step 4: Convert PEM to P12 Format
To use the certificate in certain environments or platforms that require the P12 format, you need to convert the certificate from PEM to P12. Use the following OpenSSL command:

sudo openssl pkcs12 -export -out /path_to_store_p12_file/server.p12 -in /etc/letsencrypt/live/[domain-name]/fullchain.pem -inkey /etc/letsencrypt/live/[domain-name]/privkey.pem -passin pass: -passout pass:

Step 5: Set Up Auto Renewal
Let's Encrypt certificates have a validity period of 90 days. To ensure uninterrupted service, set up a cron job to automatically renew your certificates. Follow these steps:

Delete the default Certbot cron job:

grep certbot /etc/cron.*/*
sudo rm -rf /etc/cron.d/certbot
grep certbot /etc/cron.*/*
sudo service cron reload
sudo systemctl restart cron.service

Edit the Certbot renewal configuration file:

sudo nano /etc/letsencrypt/renewal/[domain-name].conf

Update the file to add renew_hook parameter which should convert PEM to P12, replace the old certificate and restart the application (Please modify it as per your need) :

[renewalparams]
account = db23cbfd3bb32421da493553c16b78de
pref_challs = http-01,
authenticator = standalone
server = https://acme-v02.api.letsencrypt.org/directory
renew_hook = openssl pkcs12 -export -out /path_to_store_p12_file/server.p12 -in /etc/letsencrypt/live/[domain-name]/fullchain.pem -inkey /etc/letsencrypt/live/[domain-name]/privkey.pem -passin pass: -passout pass: && systemctl restart myapp

Create an override file for the Certbot timer:

sudo systemctl edit snap.certbot.renew.timer

Add the following content to the new file, specify the cron time when cerbot should check the expiration of the certificate:

[Timer]
OnCalendar=
OnCalendar=Tue *-*-* 15:30

Restart the necessary services:

sudo systemctl daemon-reload
sudo systemctl restart snap.certbot.renew.timer
sudo systemctl restart snap.certbot.renew.service

Conclusion:
By following these steps, you can easily create a DNS validation server certificate using Let's Encrypt and Certbot. The automated renewal process ensures that your certificates remain valid and up-to-date. Securing your web applications and websites has never been easier, thanks to Let's Encrypt's free and open certificate authority.

Remember to check the provided log files for any issues or errors. Please refer below commands:

# For current logs
sudo cat /var/log/letsencrypt/letsencrypt.log

# For older logs
sudo zcat /var/log/letsencrypt/letsencrypt.log.1.gz.

Hope you like my very first post.

Happy securing!