Category: Nutshell Series

Nutshell Series

How to Generate a PGP Key Pair on Windows

Manjunath

Generating a PGP key pair on Windows is straightforward using either the command line or Kleopatra. Follow these concise steps to get started.

Method 1: Using GPG Command Line

  • Step 1: Install Gpg4win/ Git cli
  • Step 2: Open Command Prompt/ Git cli.
  • Step 3: Run gpg --full-generate-key.
  • Step 4: Choose:
    • 1 for RSA and RSA.
    • 4096 for key size.
    • Expiration: set or choose 0 for none.
  • Step 5: Enter your name and email.
  • Step 6: Set a passphrase.
  • Step 7: Export keys:
    • Public key: gpg --armor --export your_email@example.com > publickey.asc
    • Private key: gpg --armor --export-secret-keys your_email@example.com > privatekey.asc

Method 2: Using Kleopatra

  • Step 1: Install Gpg4win (includes Kleopatra).
  • Step 2: Open Kleopatra.
  • Step 3: Click New Key Pair.
  • Step 4: Enter your name and email.
  • Step 5: Set a passphrase.
  • Step 6: Export keys:
    • Public key: Right-click, Export.
    • Private key: Right-click, Export Secret Keys.

Following these steps, you’ll have your PGP key pair ready for encrypting and signing data on Windows!

Azure, Azure Integration Services, Nutshell Series

Azure Tagging Strategies

Manjunath

Tags in Azure help organize resources for cost management, governance, and automation. Here’s a quick guide to effective tagging.

Common Tag Categories

  • Owner: Who is responsible for the resource (e.g., Owner).
  • Billing: Track costs (e.g., CostCenter, Project).
  • Environment: Classify resources by environment (e.g., Production, Development).
  • Application: Identify apps or services (e.g., Application, Role).
  • Compliance: Ensure security and compliance (e.g., Compliance, DataClassification).

Best Practices

  • Use consistent tag keys and values.
  • Inherit tags to all resources from resource groups.
  • Limit tags to essentials for simplicity.
  • Automate tagging using Azure Policy and CLI.
  • Leverage tags for cost tracking and governance.

“Tags are vital for managing cloud resources efficiently in Azure.”

– Azure Expert
Learn More About Azure Tags
Azure Integration Services, Nutshell Series, Technology and tricks

Symmetric vs Asymmetric Encryption

Manjunath

Symmetric Encryption

  • Key: Shared between sender and receiver.
  • Encryption: Sender encrypts using key, creating ciphertext.
  • Example: AES encryption.
  • Advantages: Faster, suitable for large data.
  • Disadvantages: Key distribution challenge, security compromised if key is leaked.

Asymmetric Encryption

  • Keys: Public for encryption, private for decryption.
  • Encryption: Sender uses recipient’s public key.
  • Decryption: Recipient uses private key.
  • Digital Signature: Sender signs with private key.
  • Verification: Recipient verifies with sender’s public key.
  • Advantages: No shared key needed; public keys distributable via CA (certificate Authority).
  • Disadvantages: Slower, computationally intensive.
Azure, Azure Integration Services, Nutshell Series, Technology and tricks

Essential Network Commands – Nutshell

Manjunath

Managing network connections and diagnosing issues can be made easier by using the right network commands. Here’s a quick guide to essential network commands for Windows, Azure Function Apps Console, and OpenSSL.

1. Windows Network Commands

Command Environment Description Example
ipconfig Windows (CMD) Displays network configuration ipconfig
Get-NetIPAddress Windows (PowerShell) PowerShell version of ipconfig Get-NetIPAddress
ping Windows (CMD) Tests connectivity to a host ping google.com
Test-Connection Windows (PowerShell) PowerShell version of ping Test-Connection google.com
tracert Windows (CMD) Traces network packet route tracert google.com
Test-NetConnection Windows (PowerShell) PowerShell version of tracert Test-NetConnection google.com -TraceRoute
netstat Windows (CMD) Shows active connections netstat -an
Get-NetTCPConnection Windows (PowerShell) PowerShell version of netstat Get-NetTCPConnection

2. Azure Function Apps Console Network Commands

Command Environment Description Example
curl Azure Function Apps Tests network/API endpoint curl https://example.com
nslookup Azure Function Apps Resolves DNS name nslookup example.com
ping Azure Function Apps Tests connectivity to a remote host ping example.com
traceroute Azure Function Apps Traces packet path to a host traceroute example.com

3. OpenSSL Command

Command Environment Description Example
openssl s_client -connect OpenSSL (CMD, Console) Tests SSL/TLS connection to a host

Pass additional parameter -tls1 or -tls1_1 or -tls1_2 or -tls1_3 or -ssl3 to check appropriate TLS/SSL protocols

 openssl s_client -connect example.com:443

These commands can simplify network troubleshooting across various environments: Windows, Azure Function Apps, and OpenSSL. With the right tools, managing your network connections becomes more efficient and secure.

Nutshell Series, Uncategorized

ASM (classic portal) vs ARM (Resource Manager)

Manjunath

Azure Service Manager (ASM) vs. Azure Resource Manager (ARM)

When managing resources in Microsoft Azure, you might encounter two different deployment models: Azure Service Manager (ASM) and Azure Resource Manager (ARM). Understanding the differences between these models is crucial for effectively managing and automating your Azure resources. Here’s a comparison between ASM and ARM:

Azure Service Manager (ASM)

Azure Service Manager (ASM), also known as the Classic deployment model, is the earlier method for managing Azure resources. Here are some key characteristics of ASM:

  • Portal: Classic Portal (https://manage.windowsazure.com)
  • Resource Management: Resources are managed individually, without the use of resource groups.
  • Deployment Model: Resources are managed through individual deployment units.
  • Features:
    • Limited support for tagging resources.
    • No native support for templates to automate deployments.
    • Does not support role-based access control (RBAC) or fine-grained access permissions.
    • Resource dependencies must be managed manually.
  • APIs: Uses a different set of APIs from ARM, with resources managed through the classic API.
  • Supported Resources: Only resources created in the classic model are supported.

Azure Resource Manager (ARM)

Azure Resource Manager (ARM) is the modern deployment model that provides advanced features and a unified management experience. Here’s what you need to know about ARM:

  • Portal: Azure Portal (https://portal.azure.com)
  • Resource Management: Uses Resource Groups to group related resources, simplifying management.
  • Deployment Model: Resources are deployed and managed using ARM templates, allowing for declarative and repeatable deployments.
  • Features:
    • Supports tagging resources for easier management and cost tracking.
    • Enables role-based access control (RBAC) for fine-grained access management.
    • Automatically manages resource dependencies within the template.
    • Provides better support for automation and DevOps practices through ARM templates and Azure DevOps.
  • APIs: Uses REST APIs provided by ARM, offering a unified management experience across different resource types.
  • Supported Resources: Includes all resources created in the ARM model, with many new Azure resources only available through ARM.

Summary

In summary, Azure Service Manager (ASM) is the older model with limited functionality and support. Azure Resource Manager (ARM) is the modern model that supports advanced features such as resource grouping, automation through templates, and RBAC. It is the recommended approach for managing resources in Azure due to its comprehensive capabilities and improved management experience.

As Azure continues to evolve, ARM remains the preferred choice for new deployments and management tasks. Transitioning to ARM is advisable to take advantage of the latest features and improvements in Azure resource management.

Nutshell Series, Technology and tricks

Pagination Types In REST APIs – Nutshell

Manjunath

Pagination is a technique used to split large datasets into smaller, manageable chunks. In REST APIs, there are several types of pagination methods. Here’s a brief overview of each:

Pagination TypeDescriptionExampleProsCons
Offset-Based PaginationClient specifies an offset and a limit to fetch a specific range of results.GET /items?offset=20&limit=10Simple to implement.Can be inefficient for large datasets as it requires skipping through a potentially large number of records.
Cursor-Based PaginationAPI uses a cursor (often a token) to fetch results based on a specific position in the dataset.GET /items?cursor=abc123More efficient for large datasets and avoids issues with data consistency.More complex to implement and requires maintaining state.
Page-Based PaginationClient specifies a page number and page size to get results for that specific page.GET /items?page=2&size=10Easy to understand and use.Can be inefficient for large datasets if pages are skipped.
Keyset-Based PaginationUses unique keys or identifiers to paginate through results. The client provides a key from the last item of the previous page.GET /items?start_after=abc123Efficient and avoids issues with data consistency.Requires a unique and sequential key and can be complex to implement.
Time-Based PaginationPagination based on time or timestamps. The client requests items before or after a specific timestamp.GET /items?before=2024-09-01T00:00:00Z&limit=10Useful for datasets where items are time-stamped, such as logs or event data.Requires careful handling of time zones and daylight saving time.
Hybrid PaginationCombines multiple pagination strategies, such as offset-based with cursor-based, to leverage the strengths of each.GET /items?offset=20&limit=10&cursor=abc123Flexibility to handle diverse use cases and improve performance.Complex to implement and maintain.
Azure, Nutshell Series, Uncategorized

ABC of cloud computing! – Nutshell

Manjunath

Cloud computing has transformed the way businesses manage and deliver technology services. Let’s break it down in simple terms, starting with the ABC of cloud computing:

A – Availability

Definition: Availability refers to the uptime and accessibility of cloud services. High availability ensures that your cloud resources are always accessible when you need them.

  • Importance: Ensures that mission-critical applications remain functional with minimal downtime.
  • Key Features: Redundancy, fault tolerance, and service-level agreements (SLAs).

B – Backup

Definition: Backup is the process of copying and storing your data in the cloud to protect against data loss or corruption.

  • Importance: Critical for disaster recovery and business continuity.
  • Key Features: Automated backups, data encryption, and versioning.

C – Cost Efficiency

Definition: Cloud computing offers flexible pricing models that allow businesses to pay only for the resources they use, leading to potential cost savings compared to traditional IT infrastructure.

  • Importance: Helps businesses optimize expenses and avoid large capital investments in hardware.
  • Key Features: Pay-as-you-go models, resource scaling, and pricing transparency.

D – Data Security

Definition: Cloud providers offer robust security measures to protect data from unauthorized access, breaches, and attacks.

  • Importance: Safeguarding sensitive data is essential for maintaining trust and compliance with regulations.
  • Key Features: Encryption, multi-factor authentication, and firewalls.

E – Elasticity

Definition: Elasticity in cloud computing refers to the ability to automatically scale resources up or down based on demand.

  • Importance: Ensures optimal resource utilization and cost efficiency.
  • Key Features: Auto-scaling, dynamic provisioning, and load balancing.

F – Flexibility

Definition: Cloud platforms provide flexibility by offering a wide range of services, platforms, and tools to meet various business needs.

  • Importance: Allows businesses to tailor their cloud environment to specific use cases.
  • Key Features: Multi-cloud strategies, platform compatibility, and APIs.

Conclusion

The ABC of cloud computing – Availability, Backup, Cost Efficiency – and beyond, such as Data Security, Elasticity, and Flexibility, provides a foundational understanding of how cloud services can transform modern businesses. By leveraging these key aspects, organizations can optimize their operations and scale effectively.

Azure, Azure Integration Services, Nutshell Series, Technology and tricks

Basic Azure CLI Commands – Nutshell

Manjunath

Authentication & Subscription


# Login to Azure:
az login

# Show current subscription:
az account show

# List all subscriptions:
az account list

# Set active subscription:
az account set --subscription <subscription-id>

Resource Groups


# Create a resource group:
az group create --name <resource-group-name> --location <location>

# List all resource groups:
az group list

# Delete a resource group:
az group delete --name <resource-group-name> --yes

Virtual Machines (VMs)


# List all VMs:
az vm list --output table

# Create a VM:
az vm create --resource-group <resource-group-name> --name <vm-name> --image <image> --admin-username <username> --admin-password <password>

# Start a VM:
az vm start --name <vm-name> --resource-group <resource-group-name>

# Stop a VM:
az vm stop --name <vm-name> --resource-group <resource-group-name>

# Delete a VM:
az vm delete --resource-group <resource-group-name> --name <vm-name>

Storage Accounts


# Create a storage account:
az storage account create --name <storage-account-name> --resource-group <resource-group-name> --location <location> --sku Standard_LRS

# List storage accounts:
az storage account list --output table

# Delete a storage account:
az storage account delete --name <storage-account-name> --resource-group <resource-group-name>

Blob Storage


# Create a container in a storage account:
az storage container create --name <container-name> --account-name <storage-account-name>

# Upload a file to a container:
az storage blob upload --container-name <container-name> --file <file-path> --name <blob-name> --account-name <storage-account-name>

# List blobs in a container:
az storage blob list --container-name <container-name> --account-name <storage-account-name> --output table

# Download a blob:
az storage blob download --container-name <container-name> --name <blob-name> --file <destination-path> --account-name <storage-account-name>

App Services


# Create an App Service plan:
az appservice plan create --name <plan-name> --resource-group <resource-group-name> --sku B1 --is-linux

# Create a web app:
az webapp create --resource-group <resource-group-name> --plan <plan-name> --name <webapp-name> --runtime "NODE|14-lts"

# List web apps:
az webapp list --output table

# Delete a web app:
az webapp delete --resource-group <resource-group-name> --name <webapp-name>

Azure Function Apps


# Create a function app:
az functionapp create --resource-group <resource-group-name> --consumption-plan-location <location> --name <functionapp-name> --storage-account <storage-account-name> --runtime <runtime>

# List function apps:
az functionapp list --output table

# Delete a function app:
az functionapp delete --resource-group <resource-group-name> --name <functionapp-name>

Service Bus


# Create a Service Bus namespace:
az servicebus namespace create --resource-group <resource-group-name> --name <namespace-name> --location <location>

# Create a Service Bus queue:
az servicebus queue create --resource-group <resource-group-name> --namespace-name <namespace-name> --name <queue-name>

# List Service Bus namespaces:
az servicebus namespace list --output table

# Delete a Service Bus namespace:
az servicebus namespace delete --resource-group <resource-group-name> --name <namespace-name>

Key Vault


# Create a Key Vault:
az keyvault create --name <keyvault-name> --resource-group <resource-group-name> --location <location>

# List Key Vaults:
az keyvault list --output table

# Delete a Key Vault:
az keyvault delete --name <keyvault-name> --resource-group <resource-group-name>

Azure Monitor


# List metrics for a resource:
az monitor metrics list --resource <resource-id>

# List activity logs:
az monitor activity-log list --output table

Logic Apps


# Create a Logic App:
az logic workflow create --resource-group <resource-group-name> --name <logic-app-name> --location <location>

# List Logic Apps:
az logic workflow list --resource-group <resource-group-name> --output table

# Delete a Logic App:
az logic workflow delete --resource-group <resource-group-name> --name <logic-app-name>

Event Grid


# Create an Event Grid topic:
az eventgrid topic create --name <topic-name> --resource-group <resource-group-name> --location <location>

# List Event Grid topics:
az eventgrid topic list --resource-group <resource-group-name> --output table

# Delete an Event Grid topic:
az eventgrid topic delete --name <topic-name> --resource-group <resource-group-name>

Event Hubs


# Create an Event Hubs namespace:
az eventhubs namespace create --name <namespace-name> --resource-group <resource-group-name> --location <location>

# Create an Event Hub:
az eventhubs eventhub create --resource-group <resource-group-name> --namespace-name <namespace-name> --name <eventhub-name>

# List Event Hubs in a namespace:
az eventhubs eventhub list --resource-group <resource-group-name> --namespace-name <namespace-name> --output table

# Delete an Event Hub:
az eventhubs eventhub delete --resource-group <resource-group-name> --namespace-name <namespace-name> --name <eventhub-name>
.Net, Azure, C#, Cloud Design Patterns, Nutshell Series, Technology and tricks

SOLID Principles (with c# examples) – Nutshell

Manjunath

SOLID Principles in .NET – Explained with Examples

SOLID Principles in .NET – Explained with Examples

The SOLID principles are five guidelines that help developers write clean, maintainable, and extensible object-oriented code.
Below we go through each principle with concise C# examples showing what is bad and what is good.

1. Single Responsibility Principle (SRP)

Rule: A class should have only one reason to change.

Bad Example

public class User
{
    public string Name { get; set; }
    public string Email { get; set; }

    public void SendEmail(string message)
    {
        // Logic to send email
    }
}

Here, User manages both data and email-sending logic. It has more than one responsibility.

Good Example

public class User
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public class EmailService
{
    public void SendEmail(string email, string message)
    {
        // Logic to send email
    }
}

User now manages only user data, while EmailService handles emails. Each has one responsibility.

2. Open/Closed Principle (OCP)

Rule: Classes should be open for extension but closed for modification.

Bad Example

public class AreaCalculator
{
    public double CalculateArea(object shape)
    {
        if (shape is Circle c)
            return Math.PI * c.Radius * c.Radius;
        if (shape is Square s)
            return s.Side * s.Side;
        return 0;
    }
}

Adding a new shape forces us to modify AreaCalculator, violating OCP.

Good Example

public abstract class Shape
{
    public abstract double Area();
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}

public class Square : Shape
{
    public double Side { get; set; }
    public override double Area() => Side * Side;
}

Each shape implements its own Area. Adding new shapes doesn’t require changing existing code.

3. Liskov Substitution Principle (LSP)

Rule: Derived classes should be substitutable for their base types without breaking behavior.

Bad Example

public class Bird
{
    public virtual void Fly() { }
}

public class Ostrich : Bird
{
    public override void Fly()
    {
        throw new NotImplementedException();
    }
}

Substituting Ostrich for Bird breaks behavior, since ostriches cannot fly.

Good Example

public abstract class Shape
{
    public abstract double Area();
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public override double Area() => Width * Height;
}

Rectangle correctly substitutes Shape and can be used anywhere Shape is expected.

4. Interface Segregation Principle (ISP)

Rule: Don’t force classes to implement methods they don’t use.

Bad Example

public interface IMachine
{
    void Print();
    void Scan();
}

public class SimplePrinter : IMachine
{
    public void Print() { }
    public void Scan() { throw new NotImplementedException(); }
}

SimplePrinter doesn’t support scanning, yet it is forced to implement it.

Good Example

public interface IPrinter
{
    void Print();
}

public interface IScanner
{
    void Scan();
}

public class MultiFunctionPrinter : IPrinter, IScanner
{
    public void Print()
    {
        Console.WriteLine("Printing document...");
    }

    public void Scan()
    {
        Console.WriteLine("Scanning document...");
    }
}

Now classes only implement what they need. A simple printer just implements IPrinter.

5. Dependency Inversion Principle (DIP)

Rule: High-level modules should not depend on low-level modules. Both should depend on abstractions.

Bad Example

public class DataManager
{
    private readonly SQLDatabase _db = new SQLDatabase();

    public void Save(string data)
    {
        _db.SaveData(data);
    }
}

public class SQLDatabase
{
    public void SaveData(string data) { }
}

DataManager is tightly coupled to SQLDatabase, making it hard to switch databases.

Good Example

public interface IDatabase
{
    void SaveData(string data);
}

public class SQLDatabase : IDatabase
{
    public void SaveData(string data)
    {
        // Save data to SQL database
    }
}

public class DataManager
{
    private readonly IDatabase _database;
    public DataManager(IDatabase database)
    {
        _database = database;
    }

    public void Save(string data)
    {
        _database.SaveData(data);
    }
}

DataManager now depends on IDatabase. Any database implementation can be injected.

Key Takeaways

  • SRP — One class, one responsibility.
  • OCP — Extend, don’t modify working code.
  • LSP — Subtypes must preserve base-class behavior.
  • ISP — Keep interfaces small and focused.
  • DIP — Depend on abstractions, not concretions.