DEV Community: Neer S

Ultimate guide of Linux commands for Monitoring

Neer S — Wed, 22 Jan 2025 14:59:42 +0000

Here are some essential commands to monitor the health and CPU utilization of your Ubuntu 22.04 server:

1. General System Information

View system information:

  uname -a

Check uptime and load average:

  uptime

View system memory and swap usage:

  free -h

2. CPU Utilization

Display real-time CPU and memory usage:

top

Press q to exit.

Better interactive process viewer:

  htop

(You may need to install it: sudo apt install htop)

Display CPU usage statistics:

  mpstat 1 5

(Install with: sudo apt install sysstat)

3. Disk Usage

Check disk space usage:

  df -h

Analyze disk usage in detail:

  du -sh *

4. Network Monitoring

View network statistics:

  ifconfig

(Install with: sudo apt install net-tools if not available)

Monitor network traffic in real-time:

  nload

(Install with: sudo apt install nload)

5. System Logs

View system logs:

  journalctl -xe

Tail system logs in real-time:

  tail -f /var/log/syslog

6. Hardware Information

View CPU information:

  lscpu

Check hardware information:

  lshw -short

(Install with: sudo apt install lshw)

7. Resource Monitoring Utilities

Install sysstat for detailed monitoring tools:

  sudo apt install sysstat

Then use commands like:

iostat (for I/O stats)
sar (system performance stats)
- Monitor system resource usage with glances:

  sudo apt install glances
  glances

8. Check Running Services

List running services:

  systemctl list-units --type=service --state=running

9. Temperature and Sensors

Install and check hardware sensors:

  sudo apt install lm-sensors
  sudo sensors-detect
  sensors

Would you like a script to combine these into a single health check?

Implement Circuit Breaker using Polly in .Net Core 8

Neer S — Sun, 22 Dec 2024 04:17:32 +0000

Overview of the Circuit Breaker Pattern

The Circuit Breaker pattern is used to handle faults in distributed systems, especially in a microservices architecture. It prevents cascading failures by detecting failing services and stopping their interaction for a specified period.

Why and When to Use Circuit Breaker:

Fail Fast: Stops unnecessary calls to failing services and saves system resources.
Service Stability: Helps maintain overall application responsiveness.
Recovery: Provides time for failing services to recover.
Example Scenarios:

External service downtime.
Database outages.
High latency in dependent services.

Step By Step Implementation in .NET Core 8

Step 1: Install Necessary NuGet Package
Install the Polly library:

dotnet add package Polly
dotnet add package Microsoft.Extensions.Http.Polly

Step 2: Create a Resilient HTTP Client with Circuit Breaker

Set up resilient HTTP clients for ProductService, CartService, and OrderService.

using Microsoft.Extensions.DependencyInjection;
using Polly;
using Polly.CircuitBreaker;
using Polly.Extensions.Http;
using System;
using System.Net.Http;

var builder = WebApplication.CreateBuilder(args);

// Register HTTP Clients with Circuit Breaker
builder.Services.AddHttpClient("ProductService", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/products");
})
.AddPolicyHandler(GetCircuitBreakerPolicy());

builder.Services.AddHttpClient("CartService", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/cart");
})
.AddPolicyHandler(GetCircuitBreakerPolicy());

builder.Services.AddHttpClient("OrderService", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/orders");
})
.AddPolicyHandler(GetCircuitBreakerPolicy());

var app = builder.Build();
app.Run();

// Circuit Breaker Policy
IAsyncPolicy<HttpResponseMessage> GetCircuitBreakerPolicy()
{
    return HttpPolicyExtensions
        .HandleTransientHttpError()
        .CircuitBreakerAsync(
            handledEventsAllowedBeforeBreaking: 3,
            durationOfBreak: TimeSpan.FromSeconds(30),
            onBreak: (exception, breakDelay) =>
            {
                Console.WriteLine($"Circuit broken: {exception.Message}");
            },
            onReset: () =>
            {
                Console.WriteLine("Circuit reset");
            },
            onHalfOpen: () =>
            {
                Console.WriteLine("Circuit in half-open state");
            });
}

Step 3: Create a Service Layer to Call HTTP Clients

Encapsulate HTTP client logic in services.

public class ProductService
{
    private readonly HttpClient _httpClient;

    public ProductService(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("ProductService");
    }

    public async Task<string> GetProductsAsync()
    {
        var response = await _httpClient.GetAsync("/list");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

public class CartService
{
    private readonly HttpClient _httpClient;

    public CartService(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("CartService");
    }

    public async Task<string> GetCartDetailsAsync()
    {
        var response = await _httpClient.GetAsync("/details");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

public class OrderService
{
    private readonly HttpClient _httpClient;

    public OrderService(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("OrderService");
    }

    public async Task<string> GetOrderDetailsAsync()
    {
        var response = await _httpClient.GetAsync("/details");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

Step 4: Register Services in Dependency Injection
Add the service classes to the dependency injection container.

builder.Services.AddScoped<ProductService>();
builder.Services.AddScoped<CartService>();
builder.Services.AddScoped<OrderService>();

Step 5: Use Services in a Controller
Consume the services in a controller.

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ShopController : ControllerBase
{
    private readonly ProductService _productService;
    private readonly CartService _cartService;
    private readonly OrderService _orderService;

    public ShopController(ProductService productService, CartService cartService, OrderService orderService)
    {
        _productService = productService;
        _cartService = cartService;
        _orderService = orderService;
    }

    [HttpGet("products")]
    public async Task<IActionResult> GetProducts()
    {
        var products = await _productService.GetProductsAsync();
        return Ok(products);
    }

    [HttpGet("cart")]
    public async Task<IActionResult> GetCart()
    {
        var cartDetails = await _cartService.GetCartDetailsAsync();
        return Ok(cartDetails);
    }

    [HttpGet("orders")]
    public async Task<IActionResult> GetOrders()
    {
        var orderDetails = await _orderService.GetOrderDetailsAsync();
        return Ok(orderDetails);
    }
}

Best Practices

1. Isolate Circuit Breakers: Use separate circuit breakers for each service.

To avoid cascading failures and ensure independent service handling, use separate circuit breakers for each service.

Use named HTTP clients with unique circuit breaker policies for each service.
Avoid sharing circuit breaker policies across multiple services.

builder.Services.AddHttpClient("ProductService", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/products");
})
.AddPolicyHandler(GetProductServiceCircuitBreakerPolicy());

builder.Services.AddHttpClient("CartService", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/cart");
})
.AddPolicyHandler(GetCartServiceCircuitBreakerPolicy());

builder.Services.AddHttpClient("OrderService", client =>
{
    client.BaseAddress = new Uri("https://api.example.com/orders");
})
.AddPolicyHandler(GetOrderServiceCircuitBreakerPolicy());

IAsyncPolicy<HttpResponseMessage> GetProductServiceCircuitBreakerPolicy() =>
    HttpPolicyExtensions
        .HandleTransientHttpError()
        .CircuitBreakerAsync(3, TimeSpan.FromSeconds(30));

IAsyncPolicy<HttpResponseMessage> GetCartServiceCircuitBreakerPolicy() =>
    HttpPolicyExtensions
        .HandleTransientHttpError()
        .CircuitBreakerAsync(2, TimeSpan.FromSeconds(20));

IAsyncPolicy<HttpResponseMessage> GetOrderServiceCircuitBreakerPolicy() =>
    HttpPolicyExtensions
        .HandleTransientHttpError()
        .CircuitBreakerAsync(5, TimeSpan.FromSeconds(60));

2. Monitor and Log: Continuously monitor circuit breaker events for debugging and alerting. Monitor events such as circuit breaking, resetting, and transitioning to a half-open state. This helps in debugging and tracking the health of services.
Use onBreak, onReset, and onHalfOpen callbacks for logging.
Leverage monitoring tools like Application Insights or ELK Stack for observability.

IAsyncPolicy<HttpResponseMessage> GetCircuitBreakerPolicyWithLogging()
{
    return HttpPolicyExtensions
        .HandleTransientHttpError()
        .CircuitBreakerAsync(
            handledEventsAllowedBeforeBreaking: 3,
            durationOfBreak: TimeSpan.FromSeconds(30),
            onBreak: (exception, timespan) =>
            {
                Console.WriteLine($"Circuit broken due to: {exception.Message}. Duration: {timespan}");
                // Log to Application Insights or other tools
            },
            onReset: () =>
            {
                Console.WriteLine("Circuit reset to closed state.");
            },
            onHalfOpen: () =>
            {
                Console.WriteLine("Circuit in half-open state. Testing health...");
            });
}

3. Graceful Fallback: Provide meaningful fallback responses when a service is unavailable. This enhances user experience and ensures the application remains functional.
Use Polly's Fallback policy in conjunction with Circuit Breaker.
Return cached or default data.

IAsyncPolicy<HttpResponseMessage> GetCircuitBreakerWithFallback()
{
    return Policy.WrapAsync(
        Policy<HttpResponseMessage>
            .Handle<Exception>()
            .FallbackAsync(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
            {
                Content = new StringContent("Service temporarily unavailable. Using fallback.")
            }),
        HttpPolicyExtensions
            .HandleTransientHttpError()
            .CircuitBreakerAsync(3, TimeSpan.FromSeconds(30))
    );
}

4. Graceful Degradation and Feature Toggles

When critical services fail, gracefully degrade functionality using feature toggles. Tools like LaunchDarkly or FeatureManagement in Azure App Configuration can help.

5. Use Centralized Configuration

Store circuit breaker configurations in a centralized location for easier updates and management. Tools like Azure App Configuration or Consul are ideal for this purpose.

public class CircuitBreakerSettings
{
    public int HandledEventsAllowedBeforeBreaking { get; set; }
    public int DurationOfBreakInSeconds { get; set; }
}

builder.Services.Configure<CircuitBreakerSettings>(
    builder.Configuration.GetSection("CircuitBreaker"));

IAsyncPolicy<HttpResponseMessage> GetCircuitBreakerPolicyWithConfig(IOptionsMonitor<CircuitBreakerSettings> options)
{
    var settings = options.CurrentValue;
    return HttpPolicyExtensions
        .HandleTransientHttpError()
        .CircuitBreakerAsync(
            settings.HandledEventsAllowedBeforeBreaking,
            TimeSpan.FromSeconds(settings.DurationOfBreakInSeconds));
}

Tools for Monitoring and Testing

Application Insights:
For logging Circuit Breaker events and tracking service health.
Azure Application Insights

ELK Stack:
ElasticSearch, Logstash, and Kibana for centralized logging.

Gremlin:

A chaos engineering tool for simulating service failures.
Gremlin

Postman/Newman:

For manual or automated testing of APIs under failure conditions.
Postman

Polly Dashboard:

Community-based dashboard for monitoring Polly policies.
Polly Dashboard GitHub

Online Resources

Polly Documentation: Polly Official Site
Circuit Breaker Design Pattern: Microsoft Learn
Microservices Best Practices: Microservices on .NET

Implement Paging, Sorting, and Searching in API (C#) and angular

Neer S — Sat, 21 Dec 2024 09:30:14 +0000

Step 1: Implement Paging, Sorting, and Searching Parameters in API (C#)

1. Create a Base Class for API Controllers:

Create a base class BaseApiController that includes properties for paging, sorting, and searching.

public abstract class BaseApiController : ControllerBase
{
    protected int DefaultPageSize { get; } = 10;

    protected int MaxPageSize { get; } = 50;

    protected BaseApiController()
    {
        DefaultPageSize = 10;
        MaxPageSize = 50;
    }

    protected int GetPageSize(int pageSize)
    {
        return pageSize > MaxPageSize ? MaxPageSize : pageSize;
    }

    protected int GetPageNumber(int pageNumber)
    {
        return pageNumber < 1 ? 1 : pageNumber;
    }
}

2. Create a Model for Request Parameters:

Create a model to hold the paging, sorting, and searching parameters.

public class QueryParameters
{
    public int PageNumber { get; set; } = 1;

    private int _pageSize = 10;
    public int PageSize
    {
        get => _pageSize;
        set => _pageSize = value > 50 ? 50 : value;
    }

    public string SortBy { get; set; }

    public string SearchTerm { get; set; }
}

Use Parameters in API Controller:

Use these parameters in your API controllers to filter and paginate data.

[Route("api/[controller]")]
[ApiController]
public class ProductsController : BaseApiController
{
    private readonly IProductService _productService;

    public ProductsController(IProductService productService)
    {
        _productService = productService;
    }

    [HttpGet]
    public IActionResult GetProducts([FromQuery] QueryParameters parameters)
    {
        var products = _productService.GetProducts(parameters);

        return Ok(products);
    }
}

Implement Pagination, Sorting, and Searching in Service:

Implement the actual logic in your service layer to apply these parameters to your data queries.

public interface IProductService
{
    IEnumerable<Product> GetProducts(QueryParameters parameters);
}

public class ProductService : IProductService
{
    private readonly AppDbContext _dbContext;

    public ProductService(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IEnumerable<Product> GetProducts(QueryParameters parameters)
    {
        var query = _dbContext.Products.AsQueryable();

        // Filtering
        if (!string.IsNullOrWhiteSpace(parameters.SearchTerm))
        {
            query = query.Where(p => p.Name.Contains(parameters.SearchTerm));
        }

        // Sorting
        if (!string.IsNullOrWhiteSpace(parameters.SortBy))
        {
            query = query.OrderByDynamic(parameters.SortBy);
        }

        // Paging
        var skipAmount = (parameters.PageNumber - 1) * parameters.PageSize;
        query = query.Skip(skipAmount).Take(parameters.PageSize);

        return query.ToList();
    }
}

Step 2: Angular 14 Frontend

Create Angular Service:

Create a service to interact with the API.

import { Injectable } from '@angular/core';
import { HttpClient, HttpParams } from '@angular/common/http';
import { Observable } from 'rxjs';
import { Product } from './product.model';

@Injectable({
  providedIn: 'root'
})
export class ProductService {
  private apiUrl = 'https://localhost:5001/api/products';

  constructor(private http: HttpClient) { }

  getProducts(pageNumber: number, pageSize: number, sortBy: string, searchTerm: string): Observable<Product[]> {
    let params = new HttpParams()
      .set('pageNumber', pageNumber.toString())
      .set('pageSize', pageSize.toString())
      .set('sortBy', sortBy)
      .set('searchTerm', searchTerm);

    return this.http.get<Product[]>(this.apiUrl, { params });
  }
}

Create Angular Component:

Create a component to display and interact with the data.

import { Component, OnInit } from '@angular/core';
import { ProductService } from './product.service';
import { Product } from './product.model';

@Component({
  selector: 'app-product-list',
  templateUrl: './product-list.component.html',
  styleUrls: ['./product-list.component.css']
})
export class ProductListComponent implements OnInit {
  products: Product[] = [];
  pageNumber = 1;
  pageSize = 10;
  sortBy = '';
  searchTerm = '';

  constructor(private productService: ProductService) { }

  ngOnInit(): void {
    this.loadProducts();
  }

  loadProducts(): void {
    this.productService.getProducts(this.pageNumber, this.pageSize, this.sortBy, this.searchTerm)
      .subscribe(products => {
        this.products = products;
      });
  }

  onPageChange(page: number): void {
    this.pageNumber = page;
    this.loadProducts();
  }

  onSortChange(sortBy: string): void {
    this.sortBy = sortBy;
    this.loadProducts();
  }

  onSearch(searchTerm: string): void {
    this.searchTerm = searchTerm;
    this.loadProducts();
  }
}

HTML Template for Component:

Create an HTML template to display the products, pagination controls, sorting options, and search input.

<div>
  <input type="text" placeholder="Search..." (input)="onSearch($event.target.value)" />

  <select (change)="onSortChange($event.target.value)">
    <option value="">Sort By</option>
    <option value="name">Name</option>
    <option value="price">Price</option>
  </select>

  <ul>
    <li *ngFor="let product of products">
      {{ product.name }} - {{ product.price }}
    </li>
  </ul>

  <div>
    <button (click)="onPageChange(pageNumber - 1)" [disabled]="pageNumber === 1">Previous</button>
    <span>Page {{ pageNumber }}</span>
    <button (click)="onPageChange(pageNumber + 1)">Next</button>
  </div>
</div>

Explanation:

In this setup, the Angular component ProductListComponent interacts with the ProductService to fetch products from the API.
The component includes methods to handle paging, sorting, and searching actions, which in turn call the appropriate methods in the service.

The API controller ProductsController receives the query parameters from the frontend and passes them to the ProductService to filter, sort, and paginate the data.

The ProductService implements the actual logic to apply these parameters to the LINQ queries against the Product entities.

Notes:
This is a basic example. You may need to adjust the code according to your specific requirements.
For sorting, you might want to add options for ascending and descending order.
For searching, you may want to implement more complex search criteria depending on your data model.
Error handling, validation, and security considerations are important aspects to add in a production-ready application.

This code provides a foundation for reusable paging, sorting, and searching features in your .NET Core 6 API with an Angular 14 frontend.

Generate 6 or 8 digit alpha numeric code using best performance in C#

Neer S — Sat, 21 Dec 2024 09:15:44 +0000

Generating a 6 or 8-digit alphanumeric code in C# involves creating a string consisting of random letters and numbers. Here is a C# example using best practices and focusing on performance:

Use a StringBuilder for efficient string concatenation.
Use RandomNumberGenerator for cryptographic security.

Cache the character array to avoid creating it repeatedly.

using System;
using System.Security.Cryptography;
using System.Text;

public class AlphaNumericCodeGenerator
{
    private static readonly char[] chars =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".ToCharArray();

    public static string GenerateCode(int length)
    {
        if (length != 6 && length != 8)
        {
            throw new ArgumentException("Code length must be either 6 or 8.", nameof(length));
        }

        using (var rng = RandomNumberGenerator.Create())
        {
            var bytes = new byte[length];
            rng.GetBytes(bytes);

            var result = new StringBuilder(length);
            foreach (var byteValue in bytes)
            {
                result.Append(chars[byteValue % chars.Length]);
            }

            return result.ToString();
        }
    }

    public static void Main()
    {
        string code6 = GenerateCode(6);
        Console.WriteLine($"6-digit code: {code6}");

        string code8 = GenerateCode(8);
        Console.WriteLine($"8-digit code: {code8}");
    }
}

Explanation:

Character Array: A cached array of characters (both upper and lower case letters and digits) to avoid creating it repeatedly.

Random Number Generator: RandomNumberGenerator is used for better randomness and security compared to Random.

StringBuilder: Used for efficient string concatenation.
Argument Validation: Ensures the length is either 6 or 8.

Random Bytes: Generates random bytes and maps each byte to a character in the chars array.

Modulo Operation: Maps each byte to a valid index in the chars array.

This code ensures the generated string is both secure and efficient.

Create scalable and fault-tolerant microservices architecture

Neer S — Sat, 21 Dec 2024 09:02:52 +0000

To make a .NET Core microservices architecture scalable, fault-tolerant, and more performant, you can utilize various tools and technologies tailored for the .NET ecosystem. Here are some key components and best practices:

Scalability

1. Containerization and Orchestration:

Docker: For containerizing .NET Core microservices to ensure consistency across different environments.
Kubernetes (with Azure Kubernetes Service - AKS): For orchestrating and managing containers at scale, providing automated deployment, scaling, and management.

2. Service Discovery and Load Balancing:

Consul: For service discovery and configuration.
Steeltoe: Provides service discovery (Eureka) and load balancing capabilities.
NGINX or HAProxy: For load balancing requests across multiple instances of microservices.

Fault Tolerance

1. Circuit Breakers:

Polly: For implementing the circuit breaker pattern, retries, and timeouts in .NET Core applications.

2. Monitoring and Logging:

Prometheus & Grafana: For monitoring system metrics and visualizing them.
Elastic Stack (Elasticsearch, Logstash, Kibana): For centralized logging and monitoring.

3. Service Mesh:

Istio: For managing microservices traffic, security, and monitoring. It provides fine-grained control over traffic behavior and resilience features like retries, failovers, and circuit breaking.

Performance

1. API Gateway:
Ocelot: A .NET Core API Gateway for managing API traffic, including rate limiting, authentication, and load balancing.
Azure API Management: For a fully managed API gateway service in Azure.

2. Caching:

Redis: For in-memory data caching to reduce database load, can be used with StackExchange.Redis client for .NET Core.
MemoryCache: Built-in .NET Core caching for small-scale caching needs.

3. Database Sharding and Replication:

Implementing sharding and replication strategies using Entity Framework Core and database-specific features to distribute load and improve read/write performance.

4. Asynchronous Communication:

Azure Service Bus: For reliable messaging and communication between microservices.
RabbitMQ: For robust message queuing.

Development and CI/CD

1. CI/CD Pipelines:

Azure DevOps: For automating the building, testing, and deployment of .NET Core microservices.
GitHub Actions: For integrated version control and continuous integration/continuous deployment pipelines.

2. Infrastructure as Code:

Terraform: For provisioning and managing infrastructure with code.
Azure Resource Manager (ARM) templates: For automating Azure resource deployment.

Security

1. Identity and Access Management:

Azure Active Directory (Azure AD): For securing APIs and managing authentication and authorization.
IdentityServer4: For implementing OAuth2 and OpenID Connect in .NET Core applications.

2. Secret Management:

Azure Key Vault: For securely storing and accessing secrets and sensitive data.

Best Practices

1. Distributed Tracing:

OpenTelemetry: For tracing requests across multiple microservices to diagnose performance issues and latency.
Application Insights: For comprehensive monitoring and tracing in Azure.

2. Blue-Green Deployments and Canary Releases:

Azure DevOps and Azure App Services: For minimizing downtime and reducing risk during deployments.

3. Health Checks and Self-Healing:

ASP.NET Core Health Checks: For implementing health checks to automatically detect and replace unhealthy instances.

By integrating these tools and practices specifically suited for .NET Core, you can build a microservices architecture that is not only scalable and fault-tolerant but also highly performant and secure.

Difference between AddScoped, AddTransient and AddSingleton in .netcore

Neer S — Sat, 21 Dec 2024 08:57:07 +0000

In .NET Core (now called .NET 5 and later), when you register services in the dependency injection (DI) container, you have different options for specifying how instances of those services are created and managed. The three main lifetime options are:

Singleton: Only one instance of the service is created for the entire application, and it is reused for each request.
services.AddSingleton();
Scoped: A new instance of the service is created for each HTTP request within the scope of that request.
services.AddScoped();
Transient: A new instance of the service is created every time it is requested.
services.AddTransient();

Additionally, there is also a method called TryAddSingleton. This method is similar to AddSingleton, but it only adds the service if it hasn't been registered before. This can be useful when you want to ensure that a particular service is only registered once.
services.AddTransient();

Here's a brief summary of each:

Singleton:
- One instance for the entire application.
- Shared across all requests.
- Useful for stateless services or services that can be shared safely.
Scoped:
- One instance per HTTP request.
- Shared within the scope of an HTTP request.
- Useful for services that need to maintain state within the context of a single request.
Transient:
- A new instance every time it is requested.
- No sharing between different parts of the application.
- Useful for lightweight, stateless services.
TryAddSingleton:
- Adds the service as a singleton if it hasn't been registered before.
- Useful to avoid unintentional duplicate registrations.

Choosing the appropriate lifetime for your services depends on the specific requirements of your application and how you want instances of those services to be managed and shared.

SEO Tools for Testing and Techniques

Neer S — Fri, 20 Dec 2024 05:44:07 +0000

Tools to test SEO Technique

1. Keyword Research and Analysis

Tools:
Google Keyword Planner
SEMrush
Ahrefs
Ubersuggest

- Techniques:

Analyze keyword search volume, competition, and relevance.
Check the ranking of targeted keywords on SERPs.

2. Website Audit

Tools:

Screaming Frog SEO Spider
Ahrefs Site Audit
SEMrush Site Audit
Google Search Console
Moz Pro

Techniques:

Check for broken links (404 errors).
Evaluate meta tags (title, description, headers).
Identify duplicate content and thin pages.
Analyze website speed and mobile-friendliness.

3. Backlink Analysis

Tools:

Ahrefs
Majestic SEO
SEMrush Backlink Analytics
Moz Link Explorer

Techniques:

Assess the quality and quantity of backlinks.
Check for spammy or toxic links.
Monitor backlinks regularly to track changes.

4. Technical SEO Analysis

Tools:

Google PageSpeed Insights
GTmetrix
WebPageTest
Lighthouse (built into Chrome DevTools)

Techniques:

Test website speed and performance.
Evaluate Core Web Vitals: LCP, FID, CLS.
Ensure proper XML sitemap and robots.txt configurations.
Check for proper URL structures and canonical tags.

5. Content Quality Analysis

Tools:

Grammarly for content quality
Copyscape or Plagiarism Checker for originality
Clearscope or SurferSEO for content optimization

Techniques:

Evaluate content relevance, readability, and keyword usage.
Ensure the content aligns with user intent.
Check for proper internal linking.

6. Mobile-Friendliness

Tools:

Google Mobile-Friendly Test
BrowserStack for device testing

Techniques:

Test website responsiveness on various devices.
Check for viewport settings and touch-friendly designs.

7. On-Page SEO Testing

Tools:

Yoast SEO (WordPress Plugin)
Rank Math
SEOptimer

Techniques:

Check meta tags, headers, and keyword placement.
Validate alt attributes for images.
Optimize internal links for better navigation.

8. Analytics and Performance Tracking

Tools:

Google Analytics
Google Search Console
Matomo Analytics

Techniques:

Monitor organic traffic trends and bounce rates.
Track user behavior and engagement metrics.

10. Competitor Analysis

Tools:

Ahrefs
SEMrush
SimilarWeb

Techniques:

Benchmark against competitors' keywords and backlinks.
Analyze competitor site architecture and content strategies.

12. Testing for Indexing Issues

Tools:

Google Search Console
Bing Webmaster Tools

Techniques:

Use the "Coverage" report to check index status.
Perform a manual site search (e.g., site:example.com) to confirm indexed pages.

Beginner SEO in React JS - React Helmet

Neer S — Fri, 20 Dec 2024 05:41:03 +0000

Using react-helmet

1. Install the library:

npm install react-helmet

2. Update your component to use react-helmet:

import React from 'react';
import { Helmet } from 'react-helmet';

const App = () => {
    const appName = "Your Application Name";
    const dynamicPageTitle = `Welcome to ${appName}`;

    return (
        <div>
            <Helmet>
                <title>{dynamicPageTitle}</title>
            </Helmet>
            <h1>Welcome to {appName}</h1>
        </div>
    );
};

export default App;

3. Result:

The page title will dynamically update, and search engines will be able to pick it up when indexing.
Using JavaScript (document.title)
You can also directly set the title in the useEffect hook:

import React, { useEffect } from 'react';

const App = () => {
    const appName = "Your Application Name";

    useEffect(() => {
        document.title = `Welcome to ${appName}`;
    }, [appName]);

    return (
        <div>
            <h1>Welcome to {appName}</h1>
        </div>
    );
};

export default App;

Best Practices for SEO

Unique Titles: Ensure each page in your app has a unique and descriptive title.
Server-Side Rendering (SSR): If your app needs better SEO, consider using frameworks like Next.js, which support server-side rendering.
Meta Tags: Along with the title, update meta tags using react-helmet or other similar methods to include descriptions, keywords, and canonical URLs.

<Helmet>
    <title>{dynamicPageTitle}</title>
    <meta name="description" content="Description of the application or page" />
    <meta name="keywords" content="your, keywords, here" />
</Helmet>

These steps ensure your React app's title is dynamically updated and optimized for search engines like Google.

Tools to test SEO Technique

1. Keyword Research and Analysis

Tools:
Google Keyword Planner
SEMrush
Ahrefs
Ubersuggest

- Techniques:

Analyze keyword search volume, competition, and relevance.
Check the ranking of targeted keywords on SERPs.

2. Website Audit

Tools:

Screaming Frog SEO Spider
Ahrefs Site Audit
SEMrush Site Audit
Google Search Console
Moz Pro

Techniques:

Check for broken links (404 errors).
Evaluate meta tags (title, description, headers).
Identify duplicate content and thin pages.
Analyze website speed and mobile-friendliness.

3. Backlink Analysis

Tools:

Ahrefs
Majestic SEO
SEMrush Backlink Analytics
Moz Link Explorer

Techniques:

Assess the quality and quantity of backlinks.
Check for spammy or toxic links.
Monitor backlinks regularly to track changes.

4. Technical SEO Analysis

Tools:

Google PageSpeed Insights
GTmetrix
WebPageTest
Lighthouse (built into Chrome DevTools)

Techniques:

Test website speed and performance.
Evaluate Core Web Vitals: LCP, FID, CLS.
Ensure proper XML sitemap and robots.txt configurations.
Check for proper URL structures and canonical tags.

5. Content Quality Analysis

Tools:

Grammarly for content quality
Copyscape or Plagiarism Checker for originality
Clearscope or SurferSEO for content optimization

Techniques:

Evaluate content relevance, readability, and keyword usage.
Ensure the content aligns with user intent.
Check for proper internal linking.

6. Mobile-Friendliness

Tools:

Google Mobile-Friendly Test
BrowserStack for device testing

Techniques:

Test website responsiveness on various devices.
Check for viewport settings and touch-friendly designs.

7. On-Page SEO Testing

Tools:

Yoast SEO (WordPress Plugin)
Rank Math
SEOptimer

Techniques:

Check meta tags, headers, and keyword placement.
Validate alt attributes for images.
Optimize internal links for better navigation.

8. Analytics and Performance Tracking

Tools:

Google Analytics
Google Search Console
Matomo Analytics

Techniques:

Monitor organic traffic trends and bounce rates.
Track user behavior and engagement metrics.

10. Competitor Analysis

Tools:

Ahrefs
SEMrush
SimilarWeb

Techniques:

Benchmark against competitors' keywords and backlinks.
Analyze competitor site architecture and content strategies.

12. Testing for Indexing Issues

Tools:

Google Search Console
Bing Webmaster Tools

Techniques:

Use the "Coverage" report to check index status.
Perform a manual site search (e.g., site:example.com) to confirm indexed pages.

Image compression in Angular 15+ and .NET Core 7

Neer S — Fri, 20 Dec 2024 05:28:36 +0000

To edit and change the aspect ratio of an image in an Angular and .NET Core 7 application, you'll need to handle image manipulation on both the client side (Angular) and the server side (.NET Core 7). Here's a general approach:

1. Client-Side (Angular) - Adjusting Aspect Ratio Before Upload

You can allow the user to upload an image, adjust the aspect ratio on the client side, and then send the modified image to the .NET Core API.

Steps in Angular:

Use an HTML file field to select the image.
Use the HTML5 Canvas API to adjust the aspect ratio before sending the image to the server.
Convert the image to a base64 or a Blob to send it to the backend API.

Example Code:

<!-- HTML for file input -->
<input type="file" (change)="onFileSelected($event)" />
<canvas #canvas></canvas>

// Angular component
import { Component, ViewChild, ElementRef } from '@angular/core';

@Component({
  selector: 'app-image-resize',
  templateUrl: './image-resize.component.html',
})
export class ImageResizeComponent {
  @ViewChild('canvas', { static: false }) canvas: ElementRef<HTMLCanvasElement>;

  onFileSelected(event: any) {
    const file = event.target.files[0];
    if (file) {
      const img = new Image();
      const reader = new FileReader();

      reader.onload = (e: any) => {
        img.src = e.target.result;

        img.onload = () => {
          const ctx = this.canvas.nativeElement.getContext('2d');
          const desiredAspectRatio = 16 / 9; // Set desired aspect ratio

          // Resize logic
          const width = img.width;
          const height = img.height;
          const currentAspectRatio = width / height;

          let newWidth = width;
          let newHeight = height;

          if (currentAspectRatio > desiredAspectRatio) {
            // Crop width to match aspect ratio
            newWidth = height * desiredAspectRatio;
          } else if (currentAspectRatio < desiredAspectRatio) {
            // Crop height to match aspect ratio
            newHeight = width / desiredAspectRatio;
          }

          // Resize and draw the image to the canvas
          this.canvas.nativeElement.width = newWidth;
          this.canvas.nativeElement.height = newHeight;
          ctx?.drawImage(img, 0, 0, newWidth, newHeight);

          // Convert canvas back to Blob or base64 for upload
          this.canvas.nativeElement.toBlob((blob) => {
            // Send blob to the .NET Core backend
            this.uploadImage(blob);
          }, 'image/jpeg');
        };
      };
      reader.readAsDataURL(file);
    }
  }

  uploadImage(blob: Blob) {
    const formData = new FormData();
    formData.append('file', blob, 'resized-image.jpg');

    // Make HTTP request to upload the image
    // this.httpClient.post('your-api-url', formData).subscribe();
  }
}

2. Server-Side (.NET Core 7) - Handling the Image

On the server side, you can receive the uploaded image, process it further if needed (e.g., validation, additional resizing), and save it.

Steps in .NET Core:

Receive the image using an API controller.
Use libraries like ImageSharp or SkiaSharp for image manipulation.

Example Code in .NET Core 7:

Install ImageSharp via NuGet:

dotnet add package SixLabors.ImageSharp --version 2.1.3

// .NET Core API Controller
[HttpPost("upload")]
public async Task<IActionResult> UploadImage(IFormFile file)
{
    if (file != null && file.Length > 0)
    {
        using var image = await Image.LoadAsync(file.OpenReadStream());

        // Resize the image if necessary
        int newWidth = 1920;
        int newHeight = (int)(newWidth / (16.0 / 9)); // Maintain 16:9 aspect ratio

        image.Mutate(x => x.Resize(newWidth, newHeight));

        // Save the image
        var savePath = Path.Combine("wwwroot", "uploads", "resized-image.jpg");
        await image.SaveAsync(savePath);

        return Ok(new { filePath = savePath });
    }

    return BadRequest("Invalid image file.");
}

3. Upload Flow

The user selects an image in Angular.
The image is resized or cropped on the client side using Canvas.
The modified image is uploaded to the .NET Core API.
The API processes the image (if necessary) and saves it.

4. Additional Considerations

Validation: Ensure the image meets size, format, and resolution requirements before resizing.
Error Handling: Implement error handling for failed uploads, invalid image formats, etc.
Image Storage: Choose appropriate storage, such as local file system, Azure Blob Storage, or AWS S3, for storing the resized images.

This setup allows you to change the aspect ratio of an image before uploading and handle it in .NET Core.

BONUS Content

Client-Server Flow

The user selects an image on the client side.
Angular resizes and compresses the image using the element and the toBlob method.
The compressed image is sent to the .NET Core backend via an HTTP POST request.
Optionally, the server can further compress or process the image and then save it.

Benefits of Client-Side Compression:

Reduces file size before sending to the server, which saves bandwidth.
Provides immediate feedback to users about image quality.

Benefits of Server-Side Compression:

Adds an extra layer of image handling, ensuring the image meets size and quality requirements.
Allows for bulk image processing after upload.
By using this approach, you can significantly reduce the image size on the client side and, if necessary, further compress it on the server side.

Best practices to Implement RTL in React Js

Neer S — Fri, 20 Dec 2024 05:27:42 +0000

1 Install RTL-Support Libraries

Install the necessary packages for managing RTL layout:

npm install rtlcss postcss-rtl

2. Update CSS/SCSS Styles

Use postcss-rtl for automatic conversion of styles.
Modify your CSS files to include logical properties like margin-inline-start and avoid hardcoded left/right styles.

3. Configure PostCSS for RTL
Add a PostCSS configuration in your project:

// postcss.config.js
module.exports = {
  plugins: {
    'postcss-rtl': {},
  },
};

3. Detect Language Direction Use a utility function to detect and apply dir="rtl":

const isRTL = (lang) => ['ar', 'he'].includes(lang);
document.documentElement.dir = isRTL(language) ? 'rtl' : 'ltr';

4. Dynamic Language Switching

Use a state management library (e.g., Redux, Context API) to toggle between ltr and rtl.

Test with RTL-Languages

Use Chrome DevTools to force RTL mode for testing.

Common Guidelines
Use Constants for Alignment: Define alignment constants:

const ALIGN_START = isRTL ? 'right' : 'left';
const ALIGN_END = isRTL ? 'left' : 'right';

Test Early and Often: Validate UI components for both LTR and RTL layouts.
Leverage Tools for Translation: Use services like Google Translate for preliminary translations and hire native speakers for accuracy.