Forem: Jin Vincent Necesario

Using EF Core In-Memory Database in ASP.NET Core Web API

Jin Vincent Necesario — Tue, 31 Mar 2026 16:50:57 +0000

I. Introduction

Have you been in a situation where you need to test a new feature with your web application without affecting the production database? Or maybe a fast prototype without setting up a whole new database.

And in this situation, you are thinking about an in-memory database, and you are right.

Didn’t you know that Entity Framework Core can help us with this situation without directly interacting with the underlying database provider?

This is where the EF Core In-Memory Database Provider comes into the picture, and where an in-memory database comes into play.

II. Chances That You Need to Use an In-Memory Database

Here are some scenarios where you need to use EF Core In-Memory Database.

Integration Testing

If you are into integration testing, you can use EF Core In-Memory Database.
Instead of mocking your repositories, you can use this EF Core In-Memory Database for a lightweight integration test.

Quick Demo

For a quick demo, validating an idea, or creating a fast spike solution, we can use in-memory to move fast without worrying about the underlying database setup.

Temporary Data Storage

If you don’t need persistence, it resets data on restart; thus, in-memory is enough for temporary data storage.

III. What is EF Core In-Memory Database Provider?

As we all know, Entity Framework Core helps developers store and retrieve data, but it also includes an in-memory database.

A database that resides in volatile memory instead of a physical disk.
To use this, we need to install Microsoft.EntityFrameworkCore.In-Memory NuGet package.

Moreover, this in-memory database is a quick and easy way to test your ASP.NET Core web applications, without the overhead of actual database operations.

IV. How to Use an In-Memory Provider?

Let’s try to do this step by step.

But before we start, please create a new Web API project, then follow the steps below.

First thing is to install Microsoft.EntityFrameworkCore.InMemory.
Or you can take a look at our project file (.csproj) for the package reference.

  <ItemGroup>
    <PackageReference Include="AutoMapper" Version="12.0.1" />
    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.25" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
  </ItemGroup>

Just a note here: we also use AutoMapper for entity-to-model mapping later.
Second, let’s create our entities.

namespace EFCoreInMemoryDbSamp.Entities;

public class Author
{
    public Guid Id { get; set; }
    public string FirstName { get; set; } = null!;
    public string LastName { get; set; } = null!;
    public DateTime BirthDate { get; set; }
    public ICollection<Book> Books { get; set; } = new List<Book>();
}

namespace EFCoreInMemoryDbSamp.Entities;
public class Book
{
    public Book(string title)
    {
        this.Title  = title;
    }
    public Guid Id { get; set; }

    public string Title { get; set; } = string.Empty;

    public string? Description { get; set; }

    public Guid AuthorId { get; set; }

    public Author? Author { get; set; }
}

Third, now that we have our Entities, let's try to create our DbContext.

using EFCoreInMemoryDbSamp.Entities;
using Microsoft.EntityFrameworkCore;

namespace EFCoreInMemoryDbSamp.Context;

public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options) : base(options)
    {
    }

    public DbSet<Author> Authors { get; set; }

    public DbSet<Book> Books { get; set; }


    override protected void OnModelCreating(ModelBuilder modelBuilder)
    {

        modelBuilder.Entity<Book>()
            .HasOne(b => b.Author)
            .WithMany(a => a.Books)
            .HasForeignKey(b => b.AuthorId);

        base.OnModelCreating(modelBuilder);

    }
}

Fourth, we need a repository to obtain the authors’ information.

using EFCoreInMemoryDbSamp.Entities;

namespace EFCoreInMemoryDbSamp.Services;

public interface IAuthorRepository
{
    Task<IEnumerable<Author>> GetAllAuthorsAsync();

    Task<Author?> GetAuthorByIdAsync(Guid id);

    Task AddAuthorAsync(Author author);

    Task DeleteAuthorAsync(Guid id);
}

Now, let’s look at the implementation of the repository interface.

using EFCoreInMemoryDbSamp.Context;
using EFCoreInMemoryDbSamp.Entities;
using Microsoft.EntityFrameworkCore;

namespace EFCoreInMemoryDbSamp.Services;

public class AuthorRepository : IAuthorRepository
{
    private MyDbContext _context;

    public AuthorRepository(MyDbContext context)
    {
        this._context = context;
    }

    public async Task AddAuthorAsync(Author author)
    {
        await this._context.Authors.AddAsync(author);
        await this._context.SaveChangesAsync();
    }

    public async Task DeleteAuthorAsync(Guid id)
    {
        var author = await this._context.Authors.SingleOrDefaultAsync(a => a.Id == id);

        if (author != null)
        {
            this._context.Authors.Remove(author);
            await this._context.SaveChangesAsync();
        }
    }

    public async Task<IEnumerable<Author>> GetAllAuthorsAsync()
    {
        return await this._context.Authors.Include(item => item.Books).ToListAsync();
    }

    public async Task<Author?> GetAuthorByIdAsync(Guid id)
    {
        Author author = new Author();

        var result = await this._context.Authors..Include(item => item.Books).SingleOrDefaultAsync(a => a.Id == id);

        if (result != null)
        {
            author = result;
        }

        return author;

    }
}

Fifth, let’s create a model and an AutoMapperprofile to use in our controller.

namespace EFCoreInMemoryDbSamp.Model;
public class Author
{
    public Guid Id { get; set; }

    public string? FirstName { get; set; }

    public string? LastName { get; set; }

    public List<Book> Books { get; set; }
}

namespace EFCoreInMemoryDbSamp.Model;

public class Book
{
    public Guid Id { get; set; }

    public string Title { get; set; } = string.Empty;

    public string? Description { get; set; }

}

using AutoMapper;

namespace EFCoreInMemoryDbSamp.Model;

public class AuthorProfile : Profile
{
    public AuthorProfile()
    {
        CreateMap<Entities.Author, Author>();
    }
}

using AutoMapper;

namespace EFCoreInMemoryDbSamp.Model
{
    public class BookProfile : Profile
    {
        public BookProfile()
        {
            CreateMap<Entities.Book, Model.Book>();
        }
    }
}

Sixth, we need a controller; in this, we created an AuthorController.

using AutoMapper;
using EFCoreInMemoryDbSamp.Model;
using EFCoreInMemoryDbSamp.Services;
using Microsoft.AspNetCore.Mvc;

namespace EFCoreInMemoryDbSamp.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class AuthorController : ControllerBase
    {
        private readonly IAuthorRepository _authorsRepository;
        private readonly IMapper _mapper;

        public AuthorController(IAuthorRepository authorRepository, IMapper mapper)
        {
            this._authorsRepository = authorRepository;
            this._mapper = mapper; 
        }

        [HttpGet]
        public async Task<ActionResult<IEnumerable<Author>>> GetAuthors()
        {
            var authorsFromRepo = await _authorsRepository.GetAllAuthorsAsync();
            return Ok(_mapper.Map<IEnumerable<Author>>(authorsFromRepo));
        }

        [HttpGet("{authorId}")]
        public async Task<ActionResult<Author>> GetAuthor(
            Guid authorId)
        {
            var authorFromRepo = await _authorsRepository.GetAuthorByIdAsync(authorId);
            if (authorFromRepo == null)
            {
                return NotFound();
            }

            return Ok(_mapper.Map<Author>(authorFromRepo));
        }
    }
}

Seventh, we need to form data, so we create a database initializer.

using EFCoreInMemoryDbSamp.Entities;

namespace EFCoreInMemoryDbSamp.Context
{
    public static class DbInitializer
    {
        public static void Seed(MyDbContext context)
        {
            var authors = new List<Author>
            {
                 new Author()
                {
                    Id = Guid.Parse("d28888e9-2ba9-473a-a40f-e38cb54f9b35"),
                    FirstName = "George",
                    LastName = "RR Martin",
                    Books = new List<Book>()
                    {
                        new Book("A Dance with Dragons")
                        {
                            Id = Guid.Parse("5b1c2b4d-48c7-402a-80c3-cc796ad49c6b"),
                            AuthorId = Guid.Parse("d28888e9-2ba9-473a-a40f-e38cb54f9b35"),
                            Description = "A Dance with Dragons is the fifth of seven planned novels in the epic fantasy series A Song of Ice and Fire."
                        },
                        new Book("A Game of Thrones")
                        {
                            Id = Guid.Parse("d8663e5e-7494-4f81-8739-6e0de1bea7ee"),
                            AuthorId = Guid.Parse("d28888e9-2ba9-473a-a40f-e38cb54f9b35"),
                            Description = "A Game of Thrones is the first novel in A Song of Ice and Fire, a series of fantasy novels by American author George R. R. ... In the novel, recounting events from various points of view, Martin introduces the plot-lines of the noble houses of Westeros, the Wall, and the Targaryens."
                        }
                    }
                },
                new Author()
                {
                    Id = Guid.Parse("da2fd609-d754-4feb-8acd-c4f9ff13ba96"),
                    FirstName = "Stephen",
                    LastName = "Fry",
                    Books = new List<Book>()
                    {
                        new Book("Mythos")
                        {
                            Id = Guid.Parse("d173e20d-159e-4127-9ce9-b0ac2564ad97"),
                            AuthorId = Guid.Parse("da2fd609-d754-4feb-8acd-c4f9ff13ba96"),
                            Description = "The Greek myths are amongst the best stories ever told, passed down through millennia and inspiring writers and artists as varied as Shakespeare, Michelangelo, James Joyce and Walt Disney.  They are embedded deeply in the traditions, tales and cultural DNA of the West.You'll fall in love with Zeus, marvel at the birth of Athena, wince at Cronus and Gaia's revenge on Ouranos, weep with King Midas and hunt with the beautiful and ferocious Artemis. Spellbinding, informative and moving, Stephen Fry's Mythos perfectly captures these stories for the modern age - in all their rich and deeply human relevance."
                        }
                    }
                },
                new Author()
                {
                    Id = Guid.Parse("24810dfc-2d94-4cc7-aab5-cdf98b83f0c9"),
                    FirstName = "James",
                    LastName = "Elroy",
                    Books = new List<Book>()
                    {
                         new Book("American Tabloid")
                         {
                            Id = Guid.Parse("493c3228-3444-4a49-9cc0-e8532edc59b2"),
                            AuthorId = Guid.Parse("24810dfc-2d94-4cc7-aab5-cdf98b83f0c9"),
                            Description = "American Tabloid is a 1995 novel by James Ellroy that chronicles the events surrounding three rogue American law enforcement officers from November 22, 1958 through November 22, 1963. Each becomes entangled in a web of interconnecting associations between the FBI, the CIA, and the mafia, which eventually leads to their collective involvement in the John F. Kennedy assassination."
                        }
                    }
                },
                new Author()
                {
                    Id = Guid.Parse("2902b665-1190-4c70-9915-b9c2d7680450"),
                    FirstName = "Douglas",
                    LastName = "Adams",
                    Books = new List<Book>()
                    {
                         new Book("The Hitchhiker's Guide to the Galaxy")
                         {
                            Id = Guid.Parse("40ff5488-fdab-45b5-bc3a-14302d59869a"),
                            AuthorId = Guid.Parse("2902b665-1190-4c70-9915-b9c2d7680450"),
                            Description = "In The Hitchhiker's Guide to the Galaxy, the characters visit the legendary planet Magrathea, home to the now-collapsed planet-building industry, and meet Slartibartfast, a planetary coastline designer who was responsible for the fjords of Norway. Through archival recordings, he relates the story of a race of hyper-intelligent pan-dimensional beings who built a computer named Deep Thought to calculate the Answer to the Ultimate Question of Life, the Universe, and Everything."
                        }
                    }
                }
            };

            if (!context.Authors.Any())
            { 
                context.Authors.AddRange(authors);
                context.SaveChanges();
            }
        }

        public static void StartSeed(this WebApplication app)
        {
            using (var scope = app.Services.CreateScope())
            {
                var context = scope.ServiceProvider.GetRequiredService<MyDbContext>();
                DbInitializer.Seed(context);
            }
        }
    }
}

Now, for our last step, go to Program.cs file and check the differences between your Program.cs file and add the related methods from our previous code samples.

using EFCoreInMemoryDbSamp.Context;
using EFCoreInMemoryDbSamp.Model;
using EFCoreInMemoryDbSamp.Services;
using Microsoft.EntityFrameworkCore;
using System.Text.Json.Serialization;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers().AddJsonOptions(options =>
{

    options.JsonSerializerOptions.PropertyNamingPolicy = null;
    options.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;

});

// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

//we need to add authorrepository 
builder.Services.AddScoped<IAuthorRepository, AuthorRepository>();

//we need to set the EF to use In Memory Database
builder.Services.AddDbContextFactory<MyDbContext>(options =>
{
    options.UseInMemoryDatabase("MyInMemory");
});

//we need to add automapper profiles
builder.Services.AddAutoMapper(typeof(AuthorProfile), typeof(BookProfile));

var app = builder.Build();

//we need some data when the application has started.
app.StartSeed();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

V. Limitations

Wow! We have seen how to use the In-Memory in EF Core, but please be aware that it has several limitations.

It will allow you to save data, but remember it is not a relational database, so no foreign key constraints, no joins enforced like SQL, so no relational behaviors.
It will allow executing queries in memory using LINQ-to-Objects, not SQL.
Transactions are either ignored or not truly enforced.

The simple rule of thumb is that EF In Memory is a fake database, like a mock, while SQL Server is the production truth.

VI. Summary

In this post, we have seen that setting up EF Core with an in-memory database is straightforward.

As we discussed, this can significantly enhance your testing capabilities by providing a quick, easy way to simulate database operations without the overhead of a full database setup.

This setup is ideal for unit tests or integration tests, quick demos, and temporary data storage, allowing you to test your data access code in isolation.

From there, a code sample was shown on how to get started with this kind of setup, and I hope you enjoyed it.
Let me know if you have any questions about the code sample in the comment section below.

If you want the full codebase, you can find it here on GitHub.

Stay tuned for more (keep visiting our blog and share this with your friends, colleagues, and network).

Until next time, happy programming!

Please don’t forget to bookmark, like, and comment. Cheers! And Thank you!

VII. References

• https://entityframeworkcore.com/providers-inmemory
• https://rmauro.dev/set-up-entity-framework-core-in-memory-store/
• https://learn.microsoft.com/en-us/ef/core/providers/in-memory/?tabs=dotnet-core-cli
• https://www.infoworld.com/article/2336587/how-to-use-ef-core-as-an-in-memory-database-in-asp-net-core-6.html

Understanding the Distinctions: PowerShell vs. Azure CLI

Jin Vincent Necesario — Thu, 26 Mar 2026 10:42:58 +0000

Introduction

In today's cloud computing era, Microsoft Azure is known as one of the leading cloud providers, offering a range of services to meet businesses' dynamic needs.

Two powerful tools frequently used in the Azure ecosystem are PowerShell and Azure Command-Line Interface (CLI).

While both serve the common goal of managing and automating tasks in Azure, they differ significantly in their approach, syntax, and capabilities.

So, let’s explore these two by starting with PowerShell, then the Azure CLI.

Hopefully, by the end of the article, you’ll agree that both of these tools should be learned when working with Azure.

PowerShell: The Power Behind Scripting

Microsoft developed PowerShell, a task automation framework and scripting language.

It is a powerful command-line interface and a scripting environment that enables users to automate tasks and manage configurations.

One of the standout features of PowerShell is its object-oriented nature, which allows the output of one command to be used seamlessly as input to another.

This object-oriented approach makes PowerShell scripts highly versatile and flexible.

Let’s discuss some attributes of PowerShell below.

Cross-Platform Support

Before we discuss other PowerShell attributes, I think it is worth noting that PowerShell is cross-platform.

However, it was initially designed for Windows environments, and PowerShell has evolved to support cross-platform use through PowerShell Core (now known as PowerShell 7), allowing users to run PowerShell on Linux and macOS, broadening its applicability across operating systems.

That’s why it is recommended to install PowerShell version 7 side by side with PowerShell (Windows).

Syntax and Scripting

For readability, PowerShell uses a Verb-Noun naming convention for its commands, which provides a consistent structure.

For example, cmdlets like Get-AzVM or New-AzResourceGroup follow this convention.

PowerShell for Windows, its scripting language, is built on the .NET framework.

In contrast, PowerShell Core (now known as PowerShell 7) is built on .NET Core, making it a robust, extensible tool for automating and managing Azure resources.
Integration with Azure

We can integrate Azure directly from PowerShell by installing the Azure PowerShell module, which provides cmdlets for various Azure services, making it a preferred choice for Windows-centric environments and users familiar with PowerShell scripting.

Integration with Azure

If you would like to know more about installing the Azure PowerShell module, here are some links for guidance:
• https://github.com/Azure/azure-powershell
• https://learn.microsoft.com/en-us/powershell/azure/install-azps-windows?view=azps-15.4.0&tabs=windowspowershell&pivots=windows-psgallery
• https://learn.microsoft.com/en-us/powershell/azure/troubleshooting?view=azps-15.4.0#az-and-azurerm-coexistence.

Azure CLI: The Command-Line Interface Approach

Now that you are in this section, you might be thinking that Azure CLI is cross-platform.

Yes, you are right, it is a cross-platform command-line tool that focuses on simplicity and ease of use, providing a consistent experience across different operating systems.

Azure CLI commands are designed to be concise and follow a logical structure.

Syntax and Scripting

The verb-noun structure, similar to PowerShell, is also used by Azure CLI commands, but with a more straightforward, concise approach.

For instance, commands like az vm list or az group create follow this convention. The scripting language is based on JSON, making it easy to understand and write scripts for Azure resource management.

Integration with Azure

Azure CLI is built to be a lightweight and efficient tool for managing Azure resources.

Not only that, it offers a wide range of commands for various Azure services, giving users the flexibility to interact with Azure resources through a familiar command-line interface.

This is the tool of choice for users who prefer a streamlined, consistent experience across platforms.

Cross-Platform Support

The main strength of Azure CLI is its native cross-platform support, which works seamlessly on Windows, Linux, and macOS, making it a perfect choice for users working in different environments.

Choosing the Right Tool

We are now in a section that lets us choose between PowerShell and Azure CLI.

Well, everything depends on users’ likes and comfort levels with both.

PowerShell will always be favored by those who are comfortable with scripting, prefer a more comprehensive, object-oriented approach, or excel in complex automation scenarios.

On the other hand, Azure CLI appeals to users seeking simplicity and consistency in their command-line interactions, and its easy-to-understand syntax makes it an excellent choice for quick tasks and those who prefer a more command-oriented approach.

Conclusion

When using Azure in a day-to-day setting, the choice between PowerShell and Azure CLI boils down to individual preferences and, of course, the complexity of the tasks at hand.

If the user is comfortable with Windows environments, PowerShell's object-oriented scripting capabilities make it a perfect choice for automating and managing Azure resources.

However, if you are seeking a consistent, efficient command-line experience across operating systems, Azure CLI is your choice.

The best advice is to master both tools so users can navigate the Azure ecosystem with greater flexibility and efficiency.

Until next time, happy programming, and good luck with your career!

Understanding Azure Resource Manager and Its Components

Jin Vincent Necesario — Sun, 22 Feb 2026 04:11:28 +0000

A Beginner’s Guide to Resource Groups, Providers, Types, and Templates

Introduction

As a developer working with Azure, we need to understand the Azure Resource Manager, which provides a management layer for other APIs. We can distinguish it from an ARM template and understand its relation to Azure Resource Group, Resource Type, and Resource Provider.

Honestly, when I first started with Azure and began to understand Azure Resource Manager, I thought ARM and ARM templates were the same thing, but they’re not.

In this post, I’ll explain my understanding of Azure Resource Manager, Resource Group, Resource Provider, Resource Type, and Azure Resource Manager Template, as well as their differences.

So let’s get started.

What is Azure Resource Manager?

In my understanding, ARM serves as the management layer for all resources in Azure.

Moreover, it provides a unified API surface that the Azure Portal, Azure CLI, Azure PowerShell, and REST clients use.

Furthermore, ARM communicates with resource providers (e.g., Microsoft Compute, Microsoft Storage, etc.) to provision and manage resources, allowing us to think of ARM as the control tower of Azure.

What is a Resource Group?

A resource group enables you to organize resources logically and serves as a primary management boundary for Microsoft to deploy, monitor, and manage resources in Azure.

Two key takeaways from grouping resources: first, categorize them by the application life cycle (e.g., dev, test, qa, preprod, and prod); and second, organize them by organizational structure, such as specific departments or locations within an organization.

Additionally, the application life cycle keeps different environments isolated, making RBAC, cost tracking, and policies a bit easier (in my opinion).

Here are some things to keep in mind about resource groups.

It is free; the resource group doesn’t cost anything and is not considered a resource itself.
A resource group doesn’t serve as a communication barrier between other resource groups.
A resource can only occupy one resource group and cannot be in multiple resource groups.

What are Resource Providers and Types?

About this concept, Resource Providers in Azure make specific categories of resources available, such as compute, storage, networking, or databases.

Imagine that it is a service that supplies resource types.

For example:

Microsoft.Compute – it provides VMs, VM scale sets, disks, and snapshots
Microsoft.Network – it provides VNets, NICs, and load balancers
Microsoft.Storage – it provides storage accounts, blob containers, and file shares.

Now, resource type is the specific type of resources within the resource provider category.

For example, let’s say the resource provider is “Microsoft.Compute”, resource types could be “virtualMachines”, “disks”, “snapshots”, and “availabilitySets”.

The key thing to remember is that “Resource Provider” is a broad service category, while “Resource Type” is a specific kind of resource within the provider.

In contrast, the “Resource Instance” is your actual deployed thing in the cloud.

What is an ARM Template?

We won’t be tackling a lot of ARM templates here, but I’ll try to give at least a good background for us to understand them.

Fundamentally, an ARM template is a JSON file that describes the state of an infrastructure, because its primary purpose is to provision and configure resources in Azure.

Moreover, it is an Infrastructure as Code (IaC) that tells ARM what to build and manage.

A good analogy would be that an ARM template is the blueprint you submit to ARM, and ARM ensures the construction happens as specified.

Now that we have a good understanding of the difference between ARM and ARM templates, I would like to reiterate that Microsoft today recommends Bicep instead of writing raw ARM templates. However, under the hood, Bicep compiles down to ARM templates.

Characteristics of ARM Templates

Now that we have a good understanding of what an ARM template is, let’s discuss its characteristics here.

Idempotent

I still recall an interview where I struggled to explain a concept (I got a mental block). However, after learning from that experience, I can confidently say that if you run the same template multiple times, the result will be the same.

So, here’s how it works:

When you deploy, ARM compares the template’s desired state vs the current state of resources.
Then, if a resource exists and matches, no change at all.
Then, if a resource exists but differs, ARM updates it to match it.
Then again, if a resource doesn’t exist, ARM creates it.

Declarative

As you describe the end state, not steps, that’s why it is a declarative thing.

In imperative tools like Azure CLI, you instruct Azure on how to perform tasks step-by-step.

Thus, ARM templates say what it should look like.

Template Driven

As a JSON template file drives the template, you define things such as resources, parameters, variables, etc. Thus, it makes deployments reusable, automatable, and consistent.

Multi-service, Multi-region, Extensible

A single ARM template can deploy virtual machines, databases, storage accounts, networking, and other resources — enabling end-to-end solutions.

Templates are multi-region, since they can target resources across different regions within the same deployment.

Templates are also extensible, allowing you to nest or link templates for modularization. Additionally, ARM continuously evolves to support new resource types and services as they are released.

Summary

In this post, we have discussed ARM, Azure Resource Group, Azure Resource Provider, Azure Resource Type, and Azure templates.

I hope you learned a lot as I shared my knowledge and understanding here. Sometimes it’s easier to understand when I write things down in my head.

Once again, I hope you have enjoyed this article as I have enjoyed writing it.

Stay tuned for more. Until next time, happy programming!

Please don’t forget to bookmark, share, like, subscribe, and comment.

Cheers! And thank you!

Understanding the Business Domain in Programming, Microservices, and .NET

Jin Vincent Necesario — Mon, 27 Nov 2023 02:17:56 +0000

Understanding the Business Domain in Programming, Microservices, and .NET

Let’s understand the business domain with programming, microservices, and .net.

Introduction

In the world of software development, especially in the context of programming, microservices, and .NET, the concept of the business domain plays a vital role in forming the architecture and design of applications.

Let’s explore the business domain, its significance, and how it fits into different architectural paradigms.

What is the Business Domain?

The software application can be designed and developed for a specific area or industry representing the business domain.

Moreover, the business domain encapsulates the rules, processes, and logic defining a business’s operations.

Examples are customer interactions, order processing, inventory management, and financial transactions.

In programming, understanding the business domain is essential for creating software that accurately models and supports a business’s real-world processes and requirements.

It involves collaborating closely with domain experts, typically individuals who deeply understand the business, processes, and complexities.

Within the context of microservices, these small collections of services are modeled around a business domain within microservices.

Business Domain

Business Domain in Microservices Architecture

Having a collection of loosely coupled, independently deployable microservices helps organization structure their application within their network and helps them to communicate.

As a result, they are a form of distributed system.

Each microservice is responsible for a well-defined set of functionalities within the business domain.

For example, in an e-commerce application, you might have microservices for handling product catalogs, order processing, payment, and user authentication.

This type of architecture allows teams to work on different system parts independently, focusing on their specific business domain expertise.

Business Domain in .NET Programming

In the .NET ecosystem, Developers portray the business domain inside an application’s business logic, which includes the rules and workflows that define how data is processed and manipulated to meet business requirements.

In a traditional three-tier architecture, the business layer is where this logic resides. The business layer in a three-tier application separates the presentation layer (user interface) from the data access layer (database interactions).

It is responsible for processing and applying business rules to the data received from the presentation layer before passing it to the data access layer for storage or retrieval.

Clean Architecture and the Business Domain

Clean Architecture is an architectural style that promotes the separation of concerns and the independence of the business logic from external problems like databases and frameworks.

In Clean Architecture, the business domain is at the system’s core, surrounded by layers representing different concerns.

Entities and Use Cases

In the innermost layer of Clean Architecture, you find entities representing the core business objects and use cases describing the application-specific workflows. This is where the actual business logic resides.

Interface Adapters

Moving outward, you have interface adapters that convert data between the external world (user interfaces or external services) and the business logic. These adapters translate the details of the external world into a format that the business logic can understand and vice versa.

Frameworks and Drivers

The outermost layer deals with frameworks and tools like databases, web frameworks, and external services. Clean Architecture should separate these concerns from the business domain to ensure flexibility and maintainability.

Clarifying the Concepts

Business Layer in Three-Tier Architecture

The business layer in a three-tier application is where the business logic is traditionally placed.

It handles the processing of data before it is persisted or retrieved.

Business Domain in Microservices

Each microservice represents a specific business capability or domain in a microservices architecture.

The business domain is distributed across these microservices, allowing for better scalability and maintainability.

Clean Architecture Equivalent

In Clean Architecture, the business domain is represented by the innermost layer, consisting of entities and use cases.

This is where the core business logic resides, independent of external concerns.

Summary

Understanding the business domain is critical in designing effective software solutions.

Whether you are working with microservices, traditional three-tier architectures, or Clean Architecture, keeping the business domain at the forefront ensures that your software aligns with the real-world requirements of the business it serves.

References

Here are some things I have read and watched to produce this content. Please watch and read them, too. Thanks.

This information or code or software is provided for informational purposes only. It should not be considered as professional coding or legal advice. Not all code or information provided may be accurate or suitable for your specific project. Consult a software development expert or legal professional before making any significant coding or legal decisions.

Exploring the Distinction Between Latency and Throughput in Computing

Jin Vincent Necesario — Mon, 20 Nov 2023 12:22:51 +0000

Let’s see the difference between latency and throughput.

Photo by Denny Müller on Unsplash

Introduction

In computing and network performance, two critical concepts often come into play: latency and throughput.

While both are essential metrics that impact the user experience, they represent distinct aspects of a system’s performance.

But before we start exploring that difference, I want to share that I was confused about these terminologies and their differences. But today, I’m happy to say I’m enlightened. I’m sharing my thoughts about these two latency and throughput.

This article will explore the differences between latency and throughput, exploring their definitions, significance, and real-world examples.

Understanding Latency: The Time Factor

It measures the time delay between the initiation of a process and the occurrence of its first noticeable effect.

In web browsing, latency could be the time it takes for a click on a link to display the corresponding webpage. Another example is in the context of computing and networks.

Latency is the time data travels from a source to a destination.

Of course, we can’t ignore some delays. These factors, such as physical distance between devices, processing delays, and network congestion, can influence this time delay differently.

Latency Measurement

Latency is measured in units of time, such as milliseconds ( ms ), microseconds ( µs ), or seconds ( s ).

Most organizations see that latency plays a crucial role in determining the responsiveness of a system.

Let’s try to see the difference between low and high latency.

Low latency is desirable when real-time interactions are essential, such as online gaming, video conferencing, or financial transactions.

High latency can lead to lag, disrupting the real-time nature of the game and negatively impacting user satisfaction. Imagine this scenario: most of them are unsatisfied users.

Consider the example of online gaming, where low latency is vital for a gaming experience. In this context, latency encompasses the time a player’s action (such as pressing a button) takes to be reflected on the screen.

Throughput: The Measure of Capacity

It measures the amount of data that can be transferred from one point to another in time. Unlike latency, which focuses on the time delay of a single operation, throughput provides an overview of a system’s overall data transfer capacity.

Throughput Measurement

You probably know this already, but it is measured in bits per second. That’s right, BPS such as kilobits per second (Kbps), megabits per second (Mbps), or gigabits per second (Gbps).

It reflects the efficiency of a system in terms of data transmission. High throughput is desirable for large data transfer scenarios, such as streaming high-definition videos, file downloads, or cloud data backups.

Consider a scenario where a user downloads a large file from a remote server. In this case, throughput is crucial because it determines how quickly the file can be transferred to the user’s device. A higher throughput allows for faster downloads, enhancing the user experience.

Real-world Examples of Latency and Throughput

Let’s explore a few real-world examples to illustrate the difference between latency and throughput further.

Video Conferencing: Balancing Latency and Throughput

In video conferencing, achieving a balance between latency and throughput is essential.

Low latency ensures that participants observe real-time reactions and responses, creating a natural and engaging conversation.

Simultaneously, sufficient throughput is necessary to transmit high-quality video and audio streams without buffering or interruptions.

Web Browsing: Emphasizing Low Latency

When you click on a link while browsing the internet, the time it takes for the corresponding webpage to load is influenced by latency.

Low latency ensures a prompt response, making the web browsing experience more fluid and responsive.

Throughput comes into play when downloading images, videos, or other content from the webpage, impacting the overall loading time.

Online Gaming: Prioritizing Low Latency

As mentioned earlier, online gaming relies heavily on low latency.

Gamers need instantaneous feedback for their actions to maintain the immersive and competitive nature of the game.

Throughput becomes important when updating game asset patches or communicating with server-side components.

Summary

Latency and throughput are distinct concepts; they are interconnected, and both play vital roles in determining the performance of a system.

The right balance between low latency and high throughput is often the key to delivering a seamless and responsive user experience.

Whether streaming videos, participating in a video conference, or engaging in online gaming, understanding the difference between latency and throughput can empower you to make informed decisions about your technology and services.

As technology advances, optimizing latency and throughput will remain essential for meeting the ever-growing demands of modern computing.

This information or code or software is provided for informational purposes only. It should not be considered as professional coding or legal advice. Not all code or information provided may be accurate or suitable for your specific project. Consult a software development expert or legal professional before making any significant coding or legal decisions.

Mastering the Infinite Game of Software Development

Jin Vincent Necesario — Thu, 02 Nov 2023 11:42:10 +0000

Photo by Angely Acevedo on Unsplash

Introduction

Software development is a unique field where the finish line constantly shifts, akin to what author and visionary Simon Sinek calls an “infinite game.”

In this ever-evolving landscape, developers need to adopt a different mindset.

Instead of focusing on end goals, it’s essential to focus on the process (I learned this the hard way).

This article explores vital insights and practical tips to help software developers thrive in the infinite game of software development.

Focus on the Process, Not the Product

Traditional project-oriented thinking in software development can lead to a fixation on delivering the final product.

However, in the infinite game, the process is the product.

Let’s try to see how we can excel in this environment:

Embrace Continuous Learning

Every project presents a chance for growth and learning.

Whether it’s a successful launch or a problematic setback, see it as a chance to gain experience.

It is essential developers and the people in the organization need to learn from their mistakes and build on their successes.

Agile and Iterative Approach

Adopting an agile development methodology can help shift your mindset towards a more process-oriented perspective.

Agile encourages incremental progress, iterative development, and collaboration with stakeholders.

This approach ensures that the development process becomes more meaningful than the outcome.

Seek Feedback

Constantly seek feedback from peers, mentors, and end-users.

Feedback loops are invaluable for improving your processes and products.

By iterating based on feedback, you can refine your skills and create better software.

Set Realistic Goals

One common pitfall in software development is taking on too much at once.

This can lead to burnout, diminished quality of work, and missed deadlines.

To succeed in the infinite game, break down your goals and tasks:

Divide and Conquer

Break large projects into smaller, manageable tasks.

This approach not only makes your work more approachable but also helps in measuring progress more effectively.

Completing these smaller tasks provides a sense of achievement, motivating you to move forward.

Prioritize Tasks

Trust me, when developing software, not all tasks are created equal. That’s why it is important to prioritize work based on importance and urgency.

Tackling high-priority items first can help you maintain focus and productivity.

I still remember working for a company where tasks were everywhere.

Collaborate and Ask for Help

There’s no shame in asking for help when needed.

Collaboration is a cornerstone of software development.

Contact colleagues, mentors, or online communities for advice and support. It’s a powerful way to learn and grow while avoiding burnout.

Take Breaks

In the fast-paced world of software development, it’s easy to get lost in your work and forget to take breaks.

However, consistent, intentional breaks are essential for your well-being and productivity.

Pomodoro Technique

It is a technique known for the time management method that encourages working in short, focused intervals (usually 25 minutes), followed by a 5-minute break.

After four such intervals, take a more extended break. This technique helps maintain concentration and prevent burnout.

Physical Activity

Sitting for extended periods can affect your health.

Set a timer to remind yourself to stand up, stretch, and move around every 20–30 minutes. This helps improve circulation and reduces physical strain.

Longer Breaks

Beyond short, frequent breaks, allocate longer breaks in your workday.

These breaks can be used for a brief walk, meditation, or other activities that help clear your mind and recharge your energy.

Find a Balance Between Work and Life

While dedication to your work is essential, it’s equally crucial to maintain a work-life balance.

Over-committing to your job can lead to burnout and negatively impact your personal life.

It happened to me multiple times, and here are some of the things I wish I had done:

Set Boundaries

Establish clear boundaries between your work and personal life.

When you’re off the clock, disconnect from work-related activities such as email or Slack.

This separation allows you to engage in your personal life without distractions.

Hobbies and Interests

Make time for activities you’re passionate about outside of work.

Pursuing hobbies and interests not only provides a mental break but also fosters creativity and a sense of fulfillment.

Sleep

Sleep is the cornerstone of productivity and well-being.

Ensure you get enough rest to stay alert and effective during work hours.

Quality Time with Loved Ones

Spend quality time with family and friends.

Cultivating relationships outside of work is essential for your mental and emotional health.

Conclusion

In the infinite software development game, the focus shifts from rigid end goals to the dynamic and ever-evolving process.

By embracing this mindset, setting realistic goals, taking regular breaks, and maintaining a work-life balance, software developers can thrive in this challenging yet rewarding field.

Remember that it’s not about reaching the finish line; it’s about enjoying the journey and continuous improvement.

In doing so, you’ll find greater satisfaction, resilience, and success in your software development career.

The Dark Side of Life as a Software Engineer: Navigating Challenges in the Digital World

Jin Vincent Necesario — Sun, 29 Oct 2023 08:51:45 +0000

Photo by Karsten Würth on Unsplash

Introduction

In the modern age, software engineers are the architects of the digital realm.

They build the apps we use, the websites we browse, and the systems that power our world.

While this profession offers many rewards, there’s a lesser-known, darker side to life as a software engineer that often goes unnoticed.

Let’s tackle them one by one.

Relentless Pressure

Software development is a field that never sleeps.

The constant demand for new features, bug fixes, and updates can lead to relentless pressure.

Tight deadlines and long working hours can affect an engineer’s mental and physical health.

Burnout is a genuine concern, and it’s a battle that many software engineers face.

Advice

Set boundaries.
Learn to say no when your workload becomes overwhelming.
Prioritize tasks and communicate with your team about realistic timelines.
Remember that your well-being is essential to your productivity.

Perfectionism Paralysis

The pursuit of perfection is a double-edged sword. In other words, engineers expect to produce flawless code (humanly impossible), which can lead to perfectionism paralysis.

The fear of making mistakes or writing suboptimal code can hinder productivity and innovation.

Moreover, this perfectionism paralysis can create a toxic work environment where the fear of failure suppresses creativity.

Advice

Embrace the idea of “good enough”.
Perfectionism can be crippling.
Focus on delivering functional, maintainable code rather than obsessing over perfection.
Mistakes are part of the learning process.

Rapid Technological Evolution

Technology evolves at an astonishing pace.

While this keeps the field exciting, it also means that software engineers must constantly update their skills.

Staying relevant in the ever-changing tech landscape requires continuous learning and adaptation, which can be overwhelming.

Advice

Embrace lifelong learning.
The tech field evolves rapidly, so continuous education is a necessity.
Take online courses, attend workshops, and join tech communities to stay updated.

Ethical Dilemmas

Software engineers often find themselves in ethical dilemmas.

They may work on projects that compromise user privacy or contribute to harmful outcomes.

Balancing the demands of the job with personal ethics can be challenging and can weigh heavily on a software engineer’s conscience.

Advice

Speak up.
If you are in an ethical dilemma, don’t hesitate to voice your concerns.
Discuss the issue with your team or manager and seek solutions that align with your values.

Isolation and Loneliness

Programming can be a solitary endeavor.

Many software engineers spend long hours working alone, leading to feelings of isolation and loneliness.

As a result, it can take a toll on mental health, as social interaction becomes limited and disrupts work-life balance.

Advice

Prioritize social interaction.
Make time for friends and family, and consider joining meetups or online communities related to your interests.
Balance your work with a healthy social life.

Gender and Diversity Gaps

The tech industry has long struggled with gender and diversity gaps.

Women and underrepresented minorities often face discrimination and bias.

As a result, it can limit opportunities for talented individuals, perpetuating inequality in the field.

Advice:

Be an ally.
Advocate for diversity and inclusion within your workplace.
Support underrepresented colleagues and engage in initiatives that promote diversity in tech.

Unpredictable Job Security

The tech industry is notorious for its boom and bust cycles.

Economic downturns or shifts in market trends can lead to unpredictable job security.

Software engineers may face layoffs or job instability, even in high-demand fields.

Advice

Build a safety net.
Save and invest wisely to create a financial cushion.
Diversify your skill set to remain competitive in the job market.
Networking and maintaining a solid professional presence can also enhance job security.

Summary

Life as a software engineer is not all glamorous and six-figure salaries.

Intense pressure, perfectionism, ethical dilemmas, isolation, and more characterize a dark side.

That’s why it is essential to be aware of these challenges.

It is because as we become more aware, it is the first step in addressing them and creating a healthier, more inclusive tech industry for all.

AWS Support Plan

Jin Vincent Necesario — Sat, 15 Jul 2023 15:14:07 +0000

Discover the range of support options that AWS provides to meet your needs. Plans include a combination of quick technical support, monitoring tools, and many more.

Introduction
Support Plans AWS Offers
Basic Support Plan
Developer Support Plan
Business Support Plan
Enterprise OnRamp Support Plan
Enterprise Support Plan
Which One is The Best for Your Organization?
Summary
References

Introduction

AWS loves their customer, so they focus on delivering excellent customer support. Different businesses require various support, and AWS got your back.

If a particular organization has excellent technical experience within its on-premises data center, moving to the AWS cloud requires learning new skills and understanding how to architect solutions for the cloud and being cost-effective simultaneously.

AWS support plan got your back. AWS hires and trains its best engineers and support team to help different clients or customers.

Navigating the AWS platform and resolving technical issues can be tedious without proper support. That’s where the AWS support plan comes into play.

In this post, we’ll try to explore the various AWS support plans.

OK, let’s get started.

Support Plans AWS Offers

AWS Support Plans are divided into five categories: Basic, Developer, Business, Enterprise On-Ramp, and Enterprise. You receive various support resources based on the plan you choose.

Let’s see them one by one.

Note: The Certified Cloud Practitioner Exam has a few questions on support levels, so you must identify them and the types of services at each level.

Basic Support Plan

This support plan is free and offers customer support for any account-related issues (including if you have problems logging into your AWS account), such as bill payments. Moreover, this is perfect for users learning AWS, who might be spending some time testing out the services and functions.

Thus, a basic support plan is accessible(free) to all AWS customers at no cost.

*Technical Support * 👨‍💻

This plan has no tech support, but you can access AWS Trusted Advisorand Service Health Dashboard.

AWS Trusted Advisor (Seven Core)

This tool or service recommends improving system performance, security, and reliability.

AWS Service Health Dashboard

This tool allows users to stay informed about service disruptions and AWS updates.

*Highlights of the Basic Support Plan * 🌟

Cost: It is free
Access to AWS Community Forums
No tech support; customer service for account and billing questions only
Access to Seven(7) Core of Trusted Advisor Checks
AWS Personal Health Dashboard

Developer Support Plan

This support plan is perfect for an organization or individual experimenting or testing in AWS. Moreover, this support plan is cost-effective for getting support within non-production workloads.

Furthermore, these websites or applications are still at the development or proof of concept or prototyping 🤖 stage. In other words, it doesn’t support any critical business requirements yet.

Thus, we can say that developer support is ideal for developers or startups because it provides a higher level of technical assistance, like troubleshooting system issues and offering guidance on AWS architecture and service.

*Technical Support * 👨‍💻

The technical support is limited to generic support, primarily around technical configuration with AWS use cases, and the support team will not be able to discuss specific application-layer problems that you might be having.

The support is also only via email, meaning no phone support is offered during business hours but with access to Cloud Support associates.

Moreover, with this support, an organization can raise unlimited cases with one (1) primary contact. The case severity and response times are within 24 hours for general guidance and within 12 hours for system-impaired issues.

*Highlights of the Developer Support Plan * 🌟

Cost: $29 per month or 3% of monthly usage, whichever is larger.
Usefulness: Experimenting in AWS at a higher intensity than the basic level.
One primary contact for technical questions.
- Unlimited number of case.
- Technicians will respond during business hours via email.
SLA: 12 hours at local business hours for an impaired system, 24 hours for general guidance.

Business Support Plan

The business support plan is it is an ideal plan for those who use AWS in production. Moreover, it’s highly recommended for production environments. Furthermore, this also gives the organization technical support with their workloads on AWS.

Moreover, the business support plan includes helping you troubleshoot interoperability issues between AWS resources and third-party software.

*Technical Support * 👨‍💻

It offers 24/7 support via email, chat, and telephone. Specific severity issues will have different response times.

Your organization can get access to AWS Infrastructure Event Management (IEM). This service offers guidance and operational support to help you with project launch events or migration tasks. It includes evaluating your organization’s AWS environment readiness, determining potential threats and ways to mitigate them, ongoing support during your actual launch (AWS is behind your organization’s launch), and post-event review.

AWS Trusted Advisor (Full Acces)

The business support plan authorizes your organization to receive full AWS Trusted Advisor checks. Where organizations can check and cross-reference their workloads against best practices and receive recommendations across the five (5) categories:

Cost Optimization
Performance
Security
Fault Tolerance
Service Limits

*Highlights of the Business Support Plan * 🌟

Cost: Higher of $100 per month or 3%-10% of monthly usage for first $10k, 7% for $10,000 to $80,000, 5% for $80,000 to $250,000.
Usefulness: Production use of AWS
Access to AWS Infrastructure Event Management
Full access to AWS Trusted Advisor
- Your organization can retrieve Trusted Advisor check data through AWS Support API.
An unlimited number of contacts can open cases
Access AWS Support API for support case automation
- Your organization can retrieve detailed information about support operations and data types in JSON format.
- Provides third-party application integration support.
SLA: 24x7 support via phone, e-mail, and chat.
- 1-hour response time to urgent support cases

Enterprise-On Ramp Support Plan

The enterprise-on-ramp support plan is recommended if the organization has business-critical workloads in AWS. Moreover, it introduced a step up with the Business Support Plan with excellent services previously unavailable for organizations who didn’t have the financial power to subscribe.

*Technical Support * 👨‍💻

This support tier plan provides the organization with a pool of Technical Account Managers (TAM). These people will provide guidance and coordinate access to programs and AWS experts.

Technical Account Managers (TAM)

Collaborates with their clients to ensure the AWS resources are utilized in a way that satisfies business requirements.
Collaborate with the development and operations teams to ensure the AWS infrastructure operates correctly.
Assists in spotting and resolving issues before they escalate into more significant concerns.

Your organization gets full 24/7 email, chat, and phone support, access to senior cloud engineers, and a 30-minute response time for business-critical technical issues.

*Highlights of the Enterprise-On Ramp Support Plan * 🌟

Cost: U5,500 per month or 10% of the monthly AWS bill, whichever is higher
Usefulness: Production and business-critical workloads on AWS.
- Includes all the features of the Business Support Plan.
Access to a pool of TAM and Concierge support team.
Access to management business reviews.
SLA: 24x7 support via phone, e-mail, and chat.
- 30-minute response time to business-critical system down.

Enterprise Support Plan

This is the last support plan of AWS which is the enterprise support plan. It is the best of the best of all the support of plans that AWS offers. Your organization will expect the best service under this plan, given its price tag (starts at $15,000.00 per month).

Moreover, this is recommended for a large organization that has mission-critical applications. Examples of such companies include Netflix, Dropbox, and Airbnb.

*Technical Support * 👨‍💻

This support tier plan provides the organization with a designated Technical Account Manager (TAM). It is like a VIP-style offering, and the organization’s TAM will actively monitor your environment and work closely with you to guide your team through the planning, design, and implementation of cloud projects.

Your organization gets full 24/7 email, chat, and phone support, access to senior cloud engineers, and a 15-minute response time for business-critical technical issues.

*Highlights of the Enterprise-On Ramp Support Plan * 🌟

Cost: $15,000 per month or 10% of monthly usage (for the first $150,000).
Usefulness: Mission-critical use of AWS
- Includes all the features of the Enterprise On-Ramp Support Plan.
Access to an assigned single Technical Account Manager (TAM) (sounds like a VIP 😊) that provides the best practice guidance and helps develop and run AWS Solutions within your organization.
SLA: 24x7 support via phone, e-mail, and chat.
- 15-minute response time to business-critical cases.

Which One is The Best for Your Organization?

In my opinion, It’s critical to take into account the particular requirements of your organization, your budget, and the required level of technical support.

You can select an AWS Support Plan that best meets the needs of your business, fits within your budget, and offers the quality of technical support you require by carefully weighing these aspects. As your needs change, keep in mind that you can always upgrade or amend your support plan.

Summary

This post has explored the different types of AWS Support plans. Moreover, every support plan has been discussed regarding what they can offer AWS users the following:

Basic Support Plan
Developer Support Plan
Business Support Plan
Enterprise-On Ramp Support Plan
Enterprise Support Plan

This article was originally written and published here.

Stay tuned for more. Until next time, happy programming and happy cloud computing!

Please remember to subscribe, bookmark, like, and comment. Cheers! and Thank you!

References

AWS Guard Duty

Jin Vincent Necesario — Sat, 08 Jul 2023 04:18:00 +0000

AWS GuardDuty is a security detection service that constantly watches your AWS accounts, EC2 workloads, applications, and stored data.

Photo by Tobias Tullius / Unsplash

Introduction

Suppose you’re wondering if there’s an AWS service designed to detect malicious activity and unauthorized behavior against your organization’s AWS account. You came to the right place.

In this article, we’ll discuss AWS Guard Duty, what it is, its key features, and simple steps on how to create one.

Ok, let’s get started then.

What is AWS Guard Duty?

Image Source: https://aws.amazon.com/guardduty/

It helps our organization to protect its AWS accounts and workloads by continuously monitoring for malicious activity and unauthorized behavior.

In other words, AWS Guard Duty is a threat detection service that can analyze and detect malicious activity against your organization’s AWS account and application workloads.

What are Some Of The Threats That AWS Guard Duty Can Detect?

Use of exposed credentials.
Any communication with malicious IP addresses and domains.
Odd activities in an AWS account.
Notice ECS instance compromises such as those associated with cryptocurrency mining.
S3 bucket compromises, like unusual S3 API activity from unauthorized access from known malicious IP addresses.

What are The Key Features of AWS Guard Duty?

In this section, let’s discuss some key points and features of AWS Guard Duty.

Threat Detection

To find potential threats and suspicious activity. AWS Guard Duty examines different data sources in your organization’s AWS environment, such as AWS CloudTrail, VPC Flow, and DNS Logs.

Anomalies and well-known attack patterns are easily pinpointed using threat intelligence and machine learning algorithms.

Intelligent Alerts

This service generates security findings and warnings when it detects a potential attack via AWS Management Console, Amazon CloudWatch Events, or Amazon Simple Notification Service (SNS).

Remember that these warnings offer comprehensive details on how the threat has been detected, including the resources that have been impacted and suggested corrective actions.

Easy Integration

Integrates efficiently with different AWS services and security tools. It only needs a few clicks to enable it; sounds easy, right?

Centralized Management

From an organization’s standpoint, they can keep an eye on many AWS accounts inside the organization using this service from a centralized master account. Furthermore, it gives the organization a comprehensive understanding of security risks affecting the entire infrastructure.

Steps on How to Create AWS Guard Duty

Sign in to AWS Management Console, find “GuardDuty” on the search bar, and then select. Then you’ll see the “Security, Identity & Compliance” Section and a button on the right side of the screen. Click “Get Started.”

After that, it will let you go to the welcome dashboard. Then click “Enable GuardDuty.”

After that, it will show you a message “You’ve successfully enabled GuardDuty.” And you’ll see the “GuardDuty” dashboard in the sample screenshot below.

Under the protection plans, you’ll be able to see if the protection plan is enabled.

Let’s see the sample findings below.

Summary

In this post, we have explored the AWS Guard Duty. We started by answering what it is, what threats it can detect, its key features, and the steps to create it.

Stay tuned for more. Until next time, happy programming and happy cloud computing!

Please remember to subscribe, bookmark, like, and comment. Cheers! and Thank you!

References

Redis EXISTS, GET, and SET via C#

Jin Vincent Necesario — Mon, 10 Apr 2023 05:51:27 +0000

In this article, we’ll explore the primary usage of Redis by adding, getting a key/value pair, and checking whether it exists. We’ll show it is done using the Redis CLI and its equivalent when using the C# language; of course, its StackExchange.RedisAPI

Photo by Christina @ wocintechchat.com on Unsplash

Introduction and Background

This article assumes that you already have a Redis-server instance where you can connect and play with it. In our previous post (I hope you have enjoyed it), we showed how to connect to a Redis-server instance. Moreover, we’ll explore the command GETand SET at least their primary usage. After that, we’ll show how to do that in a Web API application using C#.

Checking Redis Instance

First, make sure you have Redis-server installed on the machine you will use. You can type the following command to verify it.

redis-cli --version

To know the current status of your Redis server before starting. You can try the command below.

sudo service redis-server status

If the Redis server isn’t active, you can type the following command to start it.

sudo service redis-server start

Redis SET and GET Command

These Redis SET and GET commands help us set a key to a particular value and get the current value stored at the key.

Let’s try them out.

SET Sample Syntax

jinLinux% redis-cli
127.0.0.1:6379> SET thisIsMyKey "myKeyValue"
OK
127.0.0.1:6379> SET favoriteFood "adobo"
OK

As you can see, the key holds the string value when using the SET. But if we want to overwrite the previous value, we can retype the last key and set a new value.

Another thing to remember about SET is that it will automatically create a key if one does not already exist.

Let’s see an example below.

127.0.0.1:6379> SET favoriteFood "before adobo now adobo forever :-)"
OK
127.0.0.1:6379> GET favoriteFood
"before adobo now adobo forever :-)"

Another thing to notice is that it returns OK whenever we set a key to a new value. OK is the response when SET has been executed successfully. How’s that?

GET Sample Syntax

This command is evident. It gets the value of a specific key (returns the string inside the key). One thing to note is that when the key doesn’t exist, it returns NIL.

An example of the NIL.

127.0.0.1:6379> GET myKey
(nil)

An example of a successful SET and GET.

127.0.0.1:6379> SET country "Philippines"
OK
127.0.0.1:6379> GET country
"Philippines"
127.0.0.1:6379> SET country "Mexico"
OK
127.0.0.1:6379> GET country
"Mexico"

Redis EXISTS Command

The GET and SET commands are the starting point of learning Redis. However, we can use the EXISTS command if you’re wondering how to check if a key exists.

Another thing to note on this command. It returns one (1) if the key exists; otherwise, it is 0.

Let’s see an example.

127.0.0.1:6379> SET helloworld "Hello Redis"
OK
127.0.0.1:6379> EXISTS helloworld
(integer) 1
127.0.0.1:6379> EXISTS myKey
(integer) 0
127.0.0.1:6379>

Let’s try to see another example.

127.0.0.1:6379> SET myKey1 "key1"
OK
127.0.0.1:6379> SET myKey2 "key2"
OK
127.0.0.1:6379> EXISTS myKey1 myKey2
(integer) 2
127.0.0.1:6379> EXISTS hello1 myKey1 myKey2
(integer) 2
127.0.0.1:6379> EXISTS hello1 myKey1 myKey2 myKey2
(integer) 3

As we can see from the example above, we’re expecting an integer from the EXISTS command. It will be counted multiple times. However, we should be aware that the same existing key is given in the arguments numerous times.

Using EXISTS, GET and SET C# Code Sample

Nice one! You’re here in this section. In this section, we’ll try to convert those Redis CLI examples to their C# equivalent using a minimal API. OK, let’s get started.

Connect To a Redis Server

Connecting to a Redis server is relatively easy. We need to install the Microsoft.Extension.Caching.StackExchangeRedis.

After that, we need to set up the IConnectionMultiplexer.

See the example below.

var builder = WebApplication.CreateBuilder(args);
var config = builder.Configuration;
var services = builder.Services;

services.AddSingleton<IConnectionMultiplexer>(option =>
    ConnectionMultiplexer.Connect(new ConfigurationOptions
    {
        EndPoints = { "localhost:6379" },
        AbortOnConnectFail = false,
        Ssl = false,
        Password = ""

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

Check Whether a Key Exists

It is because we’re using a minimal API, we’ll create an endpoint where it will check if the key exists.

app.MapGet("/keys/{key}", async
    (IConnectionMultiplexer connection, string key) =>
{
    var redis = connection.GetDatabase();
    var result = await redis.KeyExistsAsync(key);

    return new { Message = result ? "Key exists" : "Key doesn't exists" };
});

From the example above, you’ll see that the method KeyExistsAsync check whether a key exists.

Let’s see it in action.

127.0.0.1:6379> EXISTS key123
(integer) 1
127.0.0.1:6379>

As you can see from above, the key key123 does exist. Let’s test if the endpoint will return a proper message (indicating it exists).

Get an Existing Key Via StringGetAsync

How about this time? We’ll get the value of the key.

Let’s see the endpoint’s code sample first, then see it in action.

app.MapGet("keys/GetValue", async (IConnectionMultiplexer connection, [FromQuery] string key) =>
{
    var redis = connection.GetDatabase();
    var value = (string)await redis.StringGetAsync(key);
    return new { Message = value };
});

As you can see, we used the StringGetAsync to get the existing key’s value. How easy is that?

Set a New Key Via StringSetAsync

For the last example, Can you guess the name of the method? Yap! It is obviously StringSetAsync.

Let’s see the endpoint’s code sample below.

public class KeyValue
{
    [JsonPropertyName("key")]
    public string Key { get; set; }
    [JsonPropertyName("value")]
    public string Value { get; set; }
}

app.MapPost("/keys/AddKeyValue",
    async (IConnectionMultiplexer connection, [FromBody]KeyValue keyValue) =>
{
    var redis = connection.GetDatabase();

    var result = await redis.StringSetAsync(keyValue.Key, keyValue.Value);

    return new { Message = result ? "Added successfully" : $"Unable to add" };
});

The KeyValueclass will represent the data we will pass into the endpoint.

Let’s see it in action.

That’s pretty much it.

Summary

In this post, we have discussed the following

Checking Redis Instance
Redis SET and GET Command
Redis EXISTS Command
Using EXISTS, GET and SET C# Code Sample

I hope you have enjoyed this article, as I enjoyed it while writing.

You can also find the sample code here on GitHub.

Till next time, happy programming!

Introduction to Enterprise Architecture (EA)

Jin Vincent Necesario — Sat, 29 Jan 2022 08:42:04 +0000

Introduction

In today’s digital age, most businesses run and are dependent on technology. This technology comes in several forms, but software systems are most known.

As we all know, every company provides either products to sell or services. These companies are run by their owners, managers, or corporate C-suite officers, but they’re not necessarily technology experts.

These owners don’t make tech decisions. That’s why they need help to build and buy information system that runs their businesses. This is where the enterprise architecture comes in.
In this article, we’ll discuss what’s an enterprise architect and what they do.

OK, let’s get started then.

What is Enterprise Architecture (EA)?

The word enterprise represents any organization that uses software systems, and it is not limited to companies only. It can be government institutions, nonprofit organizations, non-governmental organizations, and charities.

Enterprise Architecture (EA) is a practice and a set of skills used to align technology strategy with business strategies. Moreover, EA deals with complex relationships between an enterprise/organization, its people, the business process it supports, and systems that automate these processes.

That’s why in corporate settings, business leaders rely on enterprise architects as trusted technology advisors.

In my own perspective, an enterprise needs EA not because of the IT project complexities, but because they bridge the communication gap between business stakeholders and developers.

Just try to imagine that project status could be not in good shape due to lack of communication between the developers and business stakeholders.

That’s why you’ll see EA acts as an interpreter, translating from business needs to solution designs and finally to enterprise systems.

Therefore, we can conclude that enterprise architects support business executives in translating their vision into technology strategies that help companies succeed.

Difference Between a Developer and an Architect?

Generally, most architects started their careers as software developers.

Not everyone would agree that being a software developer is a great career, especially if you don’t love building things within the software space and solving problems by translating business problems to code.

Do you want to become an architect in the future? Being a software developer is a good stepping stone.

Now, let’s focus on the difference between developers and architects.

In my opinion, developers focus on the trees, while architects focus on the forests. These trees represent the technology or related technology the developer focuses on, while the forests represent the array of connected systems the EA focuses on.

Another difference is that software developers, their first instinct is to write code to fulfill requests from the business.

That’s why if a company doesn’t have architects, business users interact directly with developers. That’s why everything is treated as a software problem.

While architects are skilled in asking the right questions that drive purpose and intent, EA helps to keep focus on delivering business value avoiding disruption.

For example, when business users ask for new systems or features, architects help them express what they really need in actual business outcomes.

Three Main Types of Architectural Scopes

Application Architects

Application architects are the closest to the software development team. These people are also known as software architects.

These people focus on a complex IT system composed of platforms, reusable components, and software. In simple terms, we can say that application architects mainly focus on engineering problems and technology solutions related to the particular platform they specialize in.

In general, most software senior or software engineering-leads usually become or are promoted to become the application architect of the team. That’s why this role can still write code. Also, what I like about these roles is testing some proof of concept that will eventually help the project progress with the current issue they’re facing.

Moreover, when not coding, testing, or designing new ideas, this role communicates with the development team to know their progress with the design implements. This ensures that the applications’ ongoing development is built according to the plans given or suggested by the software architect.

Solution Architect

Solution architects specialize in plugging working systems together to handle complex business workflows. You’ll see them in charge of bridging the gap between business problems and technology solutions. Therefore, we can say that they are in the middle of both application and enterprise-level concerns.

That’s why we can see them as sometimes a jack of all trades because of their narrow focus on individual applications but expand their knowledge and skills when needed to broader technical and strategic concerns.

Solution architects don’t require coding skills, but some of them do understand coding. That’s why they can communicate well with a developer team.

Enterprise Architect

Enterprise architects operate strategically, working with executives to achieve company goals. Moreover, their primary goal is to align technology with business strategy.

Here are things I’ve seen in the field of EA:

They maintain the holistic vision of the development initiatives
Harmonizing requirements across the large scale projects
Guiding agile teams through business and technical roadmaps.

Try to imagine that you’re a newly onboard EA on the organization. You start by looking into the company’s mission.

From there, you derive the vision and ask why the company wants to move in a specific direction? Once you have answered the why, you’ll eventually sit down, talk with the leadership, and determine how to align everything at the strategic level.

Benefits of Building an EA Team Within an Organization

Eventually, companies outgrow consulting, contracting, or outsourcing companies for strategic decision-making. This is when companies possibly decide to create an in-house EA team or department. I’ve seen many cases of this while working for an outsourcing company.

OK, maybe you’re asking: “What’s the point of having an EA team within the organization?”. To answer this, it basically starts with the alignment between the corporate mission and product development.

In most cases, organizations with an in-house development team usually focus on the technology and face many problems at hand. Over time, they can be disconnected from the real business value of the organization. That’s why having an EA team can help the organization focus on delivering real business value.

Another significant benefit is the constant evaluation of changing requirements, and the technology available to support their business requirements are constantly shifting. Practices like Agile and Agile-Architecture can keep the development adapt to change.

Lastly, the knowledge gathered, documented, and managed by the EA is valuable. This will help the organization centralize its knowledge storage and make it available to architects, developers, and business stakeholders.

Summary

In this article, we have discussed the following,

What is Enterprise Architecture (EA)?
Difference between a developer and an architect
Three main types of architectural scopes
Benefits of building an EA team within an organization

I hope you have enjoyed this article as I have enjoyed writing it.
Stay tuned for more. Until next time, happy programming!
Please don’t forget to bookmark, like, and comment.
Cheers, and Thank you!

SQL Server Primary Keys

Jin Vincent Necesario — Sat, 22 Jan 2022 05:07:24 +0000

Introduction

Hope you're familiar with the concepts of what's a primary key in a relational database management system like SQL Server. But, you need more details to better understand it, or you need some review or refresher for yourself, you have come to the right place.

This article will discuss a primary key, entity integrity, primary key constraint, composite keys, and the benefits of a primary key.

Let's get started.

What's A Primary Key?

A primary key is a logical concept where a column or field uniquely identifies each record inside a database table. Moreover, it has multiple attributes: it must not be null, and it must be unique.

Easy to remember, right? But if you're curious, we'll test and see what will happen when we try to pass a NULL and duplicate value in a primary column in the latter part of the article.

What's Entity Integrity?

Entity integrity is a rule for practical database construction, and this practice is widely used. It is a process of enforcing the primary key for each table in a database.

Therefore, it is implemented to uniquely identify each row inside the table by specifying a primary key inside our database table.

What's a Primary Key Constraint?

A primary key constraint is a restriction that basically ensures entity integrity.

Note: Unique constraint also ensures entity integrity.

Benefits of Primary Key and Entity Integrity

Proper usage and selection of a primary key and maintaining entity integrity prevent duplicate records and other issues that would indirectly compromise the integrity of the database.

Things to Remember About Primary Keys

A primary key column cannot have NULL values.
A primary key column cannot have duplicate values.
A table can have only one primary key constraint.
When multiple columns are used as primary keys, they are called composite keys.
It is good to remember that a primary key is the default clustered index if a clustered index on the table does not exist.

Composite Keys

Now, you might ask why I see multiple primary keys in one table? Those are called composite keys.

Composite keys use two or more fields from a table to create a unique value.

Therefore, it guarantees uniqueness only when combined columns, but they don't guarantee uniqueness individually.

Creating A Primary Key on A Table

Let's show how we can define a column as a primary key.

CREATE TABLE EMPLOYEE(
[Id] int NOT NULL IDENTITY(1,1),
[FirstName] nvarchar(50),
[LastName] nvarchar(50),
[Age] int,
PRIMARY KEY (Id))

In the code sample above, we have seen that using the PRIMARY KEY then passing the column Id, we have defined the primary key of the EMPLOYEE table.

Let's try to see the result below.

Add a Primary Key on A Table

Let's recreate the table from the previous example, but we will not create the primary key.

We will create a primary key after we have created the table.

Let's try to see the code sample below.

IF EXISTS (SELECT * FROM  [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_NAME] ='EMPLOYEE')
BEGIN
    DROP TABLE EMPLOYEE;
END
GO
BEGIN
CREATE TABLE EMPLOYEE(
    [Id] int NOT NULL IDENTITY(1,1),
    [FirstName] nvarchar(50),
    [LastName] nvarchar(50),
    [Age] int);
END
GO
BEGIN
ALTER TABLE EMPLOYEE ADD PRIMARY KEY(Id);
END

Just a note, if you have removed the IDENTITY (1,1), everything will still be good and have no errors because it's an auto-incrementing column.

Although these two are used together, there's no requirement when defining a primary key column that it needs to be an identity column.

Let's try to see an example below.

IF EXISTS (SELECT * FROM  [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_NAME] ='EMPLOYEE')
BEGIN
    DROP TABLE EMPLOYEE;
END
GO
BEGIN
CREATE TABLE EMPLOYEE(
    [Id] int NOT NULL,
    [FirstName] nvarchar(50),
    [LastName] nvarchar(50),
    [Age] int);
END
GO
BEGIN
ALTER TABLE EMPLOYEE ADD PRIMARY KEY(Id);
END

Again, another note, if we have forgotten the NOT NULL that makes the Id column nullable, it will give you an error.

You'll probably see an error like this

"Cannot define a PRIMARY KEY constraint on nullable column in table 'EMPLOYEE.'"

Let's try to see an example below.

IF EXISTS (SELECT * FROM  [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_NAME] ='EMPLOYEE')
BEGIN
    DROP TABLE EMPLOYEE;
END
GO
BEGIN
CREATE TABLE EMPLOYEE(
    [Id] int, -- NOT NULL REMOVED FOR YOU TO SEE THE ERROR MESSAGE
    [FirstName] nvarchar(50),
    [LastName] nvarchar(50),
    [Age] int);
END
GO
BEGIN
ALTER TABLE EMPLOYEE ADD PRIMARY KEY(Id);
END

Let's try to see the result below.

Delete Primary Key on A Table

In this section, let's try to recreate the table again, but after creating the table, let's make a primary key with the name of [PK_ON_EMPLOYEE_TABLE].

The reason for giving the primary key a custom name is so we won't have a hard time knowing its name when we need to drop the primary key.

Let's try to see the example below.

PRINT 'STEP 0. DROP EMPLOYEE TABLE IF EXISTS'

IF EXISTS (SELECT * FROM  [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_NAME] ='EMPLOYEE')
BEGIN
    PRINT 'STEP 0.1 DROPPING EMPLOYEE TABLE'
    DROP TABLE EMPLOYEE;
END
GO

PRINT 'STEP 1. CREATE THE TABLE'

BEGIN
CREATE TABLE EMPLOYEE(
    [Id] int NOT NULL IDENTITY(1,1),
    [FirstName] nvarchar(50),
    [LastName] nvarchar(50),
    [Age] int);
PRINT 'STEP 1.1 EMPLOYEE TABLE CREATED'
END
GO

BEGIN
PRINT 'STEP 2. EMPLOYEE TABLE ADDING PRIMARY KEY [PK_ON_EMPLOYEE_TABLE]'
ALTER TABLE EMPLOYEE ADD CONSTRAINT [PK_ON_EMPLOYEE_TABLE] PRIMARY KEY(Id);
END
GO

BEGIN
PRINT 'STEP 3. EMPLOYEE TABLE REMOVING THE PRIMARY KEY'
ALTER TABLE EMPLOYEE
DROP CONSTRAINT [PK_ON_EMPLOYEE_TABLE];
END

Let's try to see the result below.

Inserting NULL values into Primary Key Column

This obviously will show an error because we're violating the primary key constraint.

Still, we'll see how the SQL Server will react when inserting NULL values out of curiosity.

Let's try to see an example below.

IF EXISTS (SELECT * FROM  [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_NAME] ='EMPLOYEE')
BEGIN
    DROP TABLE EMPLOYEE;
END
GO
BEGIN

CREATE TABLE EMPLOYEE(
    [Id] int NOT NULL,
    [FirstName] nvarchar(50),
    [LastName] nvarchar(50),
    [Age] int);
END
GO

BEGIN
ALTER TABLE EMPLOYEE ADD PRIMARY KEY(Id) ;
END
GO

BEGIN
--LET'S INSERT NULL value and expect an error
INSERT INTO [dbo].[EMPLOYEE] ([Id],[FirstName],[LastName],[Age])
VALUES
(NULL, 'Jin', 'Necesario', 100)
END
GO

Let's try to see the result below.

Inserting Duplicate Values into Primary Key Column

Again, this will obviously show an error because we're violating the primary key constraint. Still, we'll see how the SQL Server will react when inserting duplicate values out of curiosity.

Let's try to see an example below.

IF EXISTS (SELECT * FROM  [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_NAME] ='EMPLOYEE')
BEGIN
    DROP TABLE EMPLOYEE;
END
GO
BEGIN

CREATE TABLE EMPLOYEE(
    [Id] int NOT NULL,
    [FirstName] nvarchar(50),
    [LastName] nvarchar(50),
    [Age] int);
END
GO

BEGIN
ALTER TABLE EMPLOYEE ADD PRIMARY KEY(Id) ;
END
GO

BEGIN
--LET'S INSERT SAME Id value of 1 and expect an error
INSERT INTO [dbo].[EMPLOYEE] ([Id],[FirstName],[LastName],[Age])
VALUES
(1, 'Jin', 'Necesario', 100),
(2, 'Vincent','Necesario', 100),
(1, 'Jin Vincent','Necesario', 100)
END
GO

Let's try to see the result below.

Summary

In this article, we have discussed the following,

What's A Primary Key?
What's Entity Integrity?
What's a Primary Key Constraint?
Benefits of Primary Key and Entity Integrity
Things to Remember About Primary Keys
Composite Keys
Creating A Primary Key on A Table
Add a Primary Key on A Table
Delete Primary Key on A Table
Inserting NULL values into Primary Key Column
Inserting Duplicate Values into Primary Key Column
I hope you have enjoyed this article.

Once again, I hope you have enjoyed this article/tutorial as I have enjoyed writing it.

Stay tuned for more. Until next time, happy programming!

Please don't forget to bookmark, like, and comment.

Cheers! and Thank you!