Implementing Microservices with .NET Core and Angular

 Using (CQRS • Saga • Azure Service Bus • Circuit Breaker • Adapter • Patterns & Best Practices) 

TL;DR (What you'll build)

A cloud-ready microservices system where each microservice:

• Is a .NET Core Web API (REST) exposing bounded-capability endpoints.

• Uses CQRS: separate read model and write model (commands vs queries).

• Coordinates complex business workflows using SAGA (via Azure Service Bus).

• Communicates async via Azure Service Bus (topics/subscriptions or queues).

• Uses Circuit Breaker (Polly) + retry/backoff to improve resilience.

• Uses Adapter pattern for external systems and for infrastructure abstraction.

• Front-end is an Angular SPA calling an API Gateway (or BFF) that routes to microservices.

---

Architecture overview (high level)

1. API Gateway / BFF (optional): Single public endpoint, routing, auth, aggregation.

2. Microservices (multiple): each with its own database (DB-per-service), own bounded context.

   • Example services: Orders, Payments, Inventory, Customers, Shipping.

3. Azure Service Bus: topics for publish/subscribe events, queues for commands/tasks.

4. CQRS: Commands handled by write-side; queries served by optimized read DB (e.g., read replica or denormalized store like CosmosDB/SQL).

5. Sagas: Orchestrate long-running transactions (compensations) via events/messages.

6. Polly: Circuit Breaker + Retry + Timeout for outbound HTTP/Bus calls.

7. Monitoring & Logging: Application Insights, centralized logs (ELK/Serilog sink).

8. CI/CD & Hosting: Build pipeline -> container images -> AKS / App Service.

Diagram (textual):

Angular SPA -> API Gateway -> Microservice A (Commands) -> Azure Service Bus topic
                                        -> Microservice B subscribes (Updates read DB)
Microservice A -> publishes events -> Azure Service Bus -> Saga Orchestrator -> other services

---

Core design principles

• Single Responsibility & Bounded Contexts — keep microservices small and focused.

• DB-per-service — avoid shared DB to reduce coupling.

• Event-driven — communicate asynchronously where eventual consistency is acceptable.

• Idempotency — message handlers must be idempotent.

• Id-based correlation — include correlation IDs in messages for tracing.

• Resilience — use bulkheads, circuit breakers, retries, timeouts.

• Observability — structured logs, distributed tracing (W3C TraceContext).

---

Key patterns & how to apply them

1. CQRS (Command Query Responsibility Segregation)

• Write side: handles commands (POST /orders → CreateOrderCommand). Validations and state changes happen here.

• Read side: optimized projection used for queries (GET /orders/123). Read DB is updated by event subscribers.

• Implementation:

  • Commands go to controllers → Command Handlers (MediatR is common).

  • After state change, publish domain event (to Azure Service Bus).

  • Event consumers update read model (denormalized tables or NoSQL).

Example files/folders:

/OrdersService
  /Commands
    CreateOrderCommand.cs
    CreateOrderCommandHandler.cs
  /Domain
    Order.cs
    OrderAggregate.cs
  /Events
    OrderCreatedEvent.cs
  /ReadModel
    OrderReadModel.cs
    OrderProjectionHandler.cs

2. Saga (long-running transactions)

• Use Saga to coordinate multi-step flows (e.g., order -> reserve inventory -> charge payment -> ship).

• Two approaches:

  • Choreography: each service reacts to events. Simple but can be hard to reason about for complex flows.

  • Orchestration: Saga Orchestrator service sends commands to participants and listens for replies/events. Easier to visualize and control compensations.

• Implementation with Azure Service Bus:

  • Orchestrator publishes ReserveInventoryCommand to a queue.

  • Inventory service replies InventoryReservedEvent or InventoryReserveFailedEvent.

  • Orchestrator then issues ChargePaymentCommand or CompensateOrderCommand.

• Always plan for compensation (rollback-like steps) when a later step fails.

3. Azure Service Bus (Messaging)

• Use Topics + Subscriptions for publish/subscribe; Queues for point-to-point commands.

• Message schema:

  • MessageId, CorrelationId, CausationId, MessageType, Payload.

• Use dead-letter queues for poison messages and implement retries & DLQ handling.

4. Circuit Breaker & Resilience (Polly)

• Wrap all outbound network calls (HTTP, DB, Service Bus operations) with retry + jittered backoff + circuit breaker.

• Typical policy: Retry (3 attempts, exponential backoff) + Circuit Breaker (open after 5 failures for 30s) + Timeout (5s).

• Example: use HttpClientFactory with Polly policies.

5. Adapter Pattern

• Use adapters to isolate external/specific client libs (e.g., Azure Service Bus SDK, Payment Gateway SDK) from your domain.

• Define an interface (e.g., IPaymentGateway) and implement StripeAdapter/DummyAdapter. This supports testability and swapping providers.

6. Repository + Unit of Work (when needed)

• Use repository for aggregate persistence; Unit of Work if multiple repositories within same DB transaction (but prefer small transactions).

7. Anti-Corruption Layer

• When integrating with legacy systems, use an adapter/anti-corruption layer to map incompatible models.

---

Concrete implementation steps

1. Set up projects

Solution example:

/MyEshop
  /src
    /ApiGateway (aspnet core)
    /Services
      /Orders.Api
      /Inventory.Api
      /Payments.Api
      /Saga.Orchestrator
    /Shared
      /Messaging (contracts)
      /Common (logging, exceptions)
  /ui
    /angular-spa

2. Shared contracts & DTOs

Create a Shared/Messaging project with message types (events/commands) used across services. Strongly-typed messages reduce coupling.

Example OrderCreatedEvent:

public record OrderCreatedEvent(Guid OrderId, Guid CustomerId, decimal Total, IEnumerable<OrderLineDto> Lines);

3. Implement CQRS in a service (Orders example)

• Use MediatR for intra-service command/handler pattern.

• Controller:

[HttpPost]
public async Task<IActionResult> Create([FromBody] CreateOrderRequest req)
{
    var cmd = new CreateOrderCommand(req.CustomerId, req.Lines);
    var result = await _mediator.Send(cmd);
    return CreatedAtAction(..., result.OrderId);
}

• CommandHandler:

public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, CreateOrderResult>
{
    private readonly IOrderRepository _repo;
    private readonly IMessageBus _bus; // adapter over Azure Service Bus

    public async Task<CreateOrderResult> Handle(CreateOrderCommand request, CancellationToken token)
    {
        var order = Order.Create(request.CustomerId, request.Lines);
        await _repo.AddAsync(order);
        await _repo.UnitOfWork.SaveChangesAsync();

        // publish event to bus
        await _bus.Publish(new OrderCreatedEvent(order.Id, order.CustomerId, order.Total, order.Lines));

        return new CreateOrderResult(order.Id);
    }
}

4. Publish/Subscribe (Azure Service Bus)

• Implement IMessageBus adapter that wraps Azure Service Bus ServiceBusClient.

• For publishing events:

public async Task Publish<T>(T @event) where T : class
{
    var message = JsonSerializer.Serialize(@event);
    await _sender.SendMessageAsync(new ServiceBusMessage(message) { MessageId = Guid.NewGuid().ToString() });
}

• For subscriptions, create background services (hosted services) to process messages and project read model.

5. Saga Orchestration (example flow)

• Orders publishes OrderCreatedEvent.

• Saga.Orchestrator subscribes. On OrderCreated:

  1. Send ReserveInventoryCommand to Inventory queue.

  2. Wait for InventoryReservedEvent or InventoryReserveFailedEvent.

  3. If reserved, send ChargePaymentCommand to Payments.

  4. If payment succeeds, send ShipOrderCommand to Shipping.

  5. If any step fails, run compensating actions (e.g., ReleaseInventoryCommand, RefundPaymentCommand) and mark order Failed.

Orchestrator pattern: implement state persistence for saga instances (e.g., in CosmosDB/SQL). Store Saga state keyed by CorrelationId.

6. Circuit Breaker with HttpClientFactory + Polly

Register in Program.cs:

services.AddHttpClient("payments", client => { client.BaseAddress = new Uri(config["Payments:BaseUrl"]); })
  .AddPolicyHandler(GetRetryPolicy())
  .AddPolicyHandler(GetCircuitBreakerPolicy());

IAsyncPolicy<HttpResponseMessage> GetRetryPolicy() =>
  HttpPolicyExtensions.HandleTransientHttpError()
    .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

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

7. Angular front-end (simple BFF pattern)

• Angular calls API Gateway/BFF endpoints which route to microservices.

• Use typed services, interceptors for auth (JWT) and correlation headers.

Example Angular service:

@Injectable({ providedIn: 'root' })
export class OrdersService {
  constructor(private http: HttpClient) {}
  createOrder(order: CreateOrderDto) {
    return this.http.post<ApiResponse<OrderView>>('/api/orders', order);
  }
}

Add an HTTP interceptor to send x-correlation-id header and Authorization bearer token.

8. Idempotency & Message deduplication

• Keep ProcessedMessage table with MessageId to ignore duplicate message deliveries.

• Use Service Bus message-id + dedupe logic.

9. Testing

• Unit test command handlers and domain logic.

• Integration tests for message flows (use in-memory or test instance of Service Bus or use the Azure Service Bus emulator).

• Contract tests for message contracts.

10. Observability, Monitoring & Health

• Use Application Insights (or OpenTelemetry) for distributed tracing and metrics.

• Add Health Checks endpoints and Kubernetes liveness/readiness probes.

• Structured logging with Serilog, sink to central store.

---

Deployment & CI/CD (short)

• Dockerize each service.

• Build pipeline: build -> test -> image -> push to ACR.

• Deploy pipeline: pull image -> AKS (Kubernetes manifests) or Azure App Service.

• Use Helm charts for Kubernetes; include config via ConfigMaps and secrets via Azure Key Vault.

• Use canary / blue-green with ingress controller and feature flags (LaunchDarkly or open-source).

---

Practical tips & pitfalls

• Do not share a single database across services — this creates high coupling.

• Prefer eventual consistency; design UIs to show pending states (e.g., "Payment Processing").

• Compensation is not rollback — design compensating actions carefully.

• Keep messages small and versionable — maintain backward compatibility.

• Start with choreography for simple flows; move to orchestrator for complex flows requiring centralized control.

• Use feature toggles while deploying new message flows.

---

Minimal code sample: publish event to Service Bus (adapter)

public interface IMessageBus
{
    Task PublishAsync<T>(T @event, string topicName);
}

public class AzureServiceBusAdapter : IMessageBus
{
    private readonly ServiceBusClient _client;
    public AzureServiceBusAdapter(ServiceBusClient client) => _client = client;

    public async Task PublishAsync<T>(T @event, string topicName)
    {
        var sender = _client.CreateSender(topicName);
        var body = JsonSerializer.Serialize(@event);
        var msg = new ServiceBusMessage(body) { MessageId = Guid.NewGuid().ToString() };
        msg.ApplicationProperties["MessageType"] = typeof(T).FullName;
        await sender.SendMessageAsync(msg);
    }
}

---

Folder structure suggestion (service-level)

/Orders.Api
  /Controllers
  /Commands
  /CommandHandlers
  /Domain
  /Events
  /Projections
  /Infrastructure
     /Persistence
     /Messaging (ServiceBus adapter)
     /HttpClients (adapters)
  /Services (business services)
  /Tests

---

Checklist before go-live

• Message contracts versioned & documented.

• Idempotency & DLQ handled.

• Circuit breakers instrumented.

• Health checks + readiness gates.

• Logging and distributed tracing configured.

• Saga persistence & compensations tested.

• Secure secrets (Key Vault) and communication (TLS, JWT).

---

Suggested next steps (practical small milestones)

1. Create a Shared.Messaging project with event/command contracts.

2. Scaffold Orders service with basic create order command and publisher (no Saga yet).

3. Create Inventory service subscriber to update read model.

4. Add Azure Service Bus adapter and test end-to-end message flow locally (or in dev subscription).

5. Implement a simple saga orchestrator for a 3-step flow (inventory → payment → shipping).

6. Add Polly policies and instrument logging/tracing.

7. Dockerize and deploy to a dev cluster.

🚀 Azure Cloud Services Benefits – A Complete Guide for Modern Applications

Cloud adoption has become the backbone of modern businesses, and Microsoft Azure stands out as one of the most powerful cloud platforms. Whether you’re building a simple website or a complex enterprise-grade microservices application, Azure provides everything from identity management to DevOps-ready container orchestration.

In this article, let’s explore how Azure works step by step, its benefits, and how you can use it with .NET Core backend + Angular frontend applications.

---

🔑 1. User Creation, Groups & Permissions (Azure Active Directory)

Every cloud journey starts with identity and access management. In Azure, this is handled by Azure Active Directory (Azure AD).

✅ How It Works

• User Creation: Admins can create users in Azure AD (manual entry, bulk import, or synced from on-premises AD).

• Groups: Users can be organized into groups (e.g., Developers, Testers, Admins).

• Permissions (Role-Based Access Control - RBAC): Instead of assigning permissions to individuals, you assign them to groups or roles (e.g., Contributor, Reader, Owner).

• Single Sign-On (SSO): One login can access Azure Portal, Microsoft 365, and custom business apps.

👉 Example:

• A developer group can get “Contributor” rights to deploy apps.

• A tester group can get “Reader” rights to monitor apps but not make changes.

This ensures security, compliance, and streamlined management.

---

🌐 2. Hosting in Azure (Web Apps & App Services)

Azure makes application hosting simple and scalable with Azure App Services.

✅ Benefits

• Host .NET Core APIs and Angular UI with minimal configuration.

• Automatic scaling (based on traffic).

• Continuous Deployment from GitHub, Azure DevOps, or local machine.

• Built-in monitoring and logging.

👉 Example:

• Host your .NET Core Web API in one App Service.

• Deploy your Angular UI as a Static Web App or in the same App Service.

---

🐳 3. Containers with Docker

For teams adopting DevOps and portability, Docker on Azure is a game-changer.

✅ How It Works

• Docker Images: Package your app (.NET API + Angular frontend) into lightweight containers.

• Azure Container Registry (ACR): Store your private Docker images.

• Azure App Service for Containers: Run Docker containers directly without managing infrastructure.

👉 Example:
Instead of worrying about server OS and dependencies, you just push your Docker image to ACR and run it.

---

☸️ 4. Kubernetes with Azure Kubernetes Service (AKS)

When applications grow and need scalability, high availability, and microservices, AKS (Azure Kubernetes Service) is the right choice.

✅ Benefits

• Automates container orchestration (deployment, scaling, self-healing).

• Load balances traffic between microservices.

• Integrates with Azure Monitor and Azure DevOps for CI/CD.

• Secure communication with Azure AD + RBAC.

👉 Example:
Your .NET Core APIs (User Service, Order Service, Payment Service) run as separate containers. Angular frontend consumes these APIs. Kubernetes ensures uptime even if one container crashes.

---

📩 5. Messaging with Azure Service Bus

Modern apps often need asynchronous communication between services. That’s where Azure Service Bus helps.

✅ Benefits

• Decouples microservices with queues and topics.

• Reliable delivery of messages, even during downtime.

• Supports FIFO (First-In-First-Out) and pub/sub messaging.

👉 Example:

• When a user places an order, the Order Service publishes a message to Service Bus.

• Payment Service and Inventory Service consume the message independently.

This makes your app more resilient and scalable.

---

🧩 6. Microservices Architecture in Azure

Azure supports building microservices-based applications using:

• AKS (Kubernetes) for orchestration.

• Azure Service Bus for communication.

• Azure API Management for unified API gateway.

• Cosmos DB / SQL Server for data storage.

👉 Example Setup:

• Authentication Service – Validates users via Azure AD.

• Order Service – Handles order logic.

• Payment Service – Processes payments.

• Notification Service – Sends email/SMS updates.

Each service runs independently in containers, communicates via Service Bus, and scales individually.

---

💻 7. .NET + Angular on Azure

One of the most common enterprise stacks is .NET Core backend + Angular frontend, and Azure provides full support.

✅ Typical Workflow

1. Develop your .NET Core Web APIs.

2. Build your Angular UI.

3. Containerize both apps with Docker.

4. Push images to Azure Container Registry.

5. Deploy via AKS (Kubernetes) or App Services.

6. Secure with Azure AD authentication.

7. Use Azure DevOps CI/CD pipelines for automated builds & deployments.

👉 Example CI/CD Flow:

• Code pushed to GitHub → Azure DevOps pipeline builds Docker images → Images stored in ACR → AKS auto-deploys latest containers → Angular app fetches API data.

---

🎯 Final Thoughts

Azure Cloud Services provide end-to-end solutions for hosting, security, scalability, and modern app development. Whether you’re a startup building a simple web app or an enterprise handling millions of transactions, Azure gives you:

• Identity & Security with Azure AD

• Reliable Hosting with App Services

• Portability with Docker

• Scalability with Kubernetes

• Asynchronous Messaging with Service Bus

• Modern Architecture with Microservices

• Seamless Development with .NET + Angular + DevOps

If you’re moving your apps to the cloud, Azure is not just an option – it’s a complete ecosystem for growth and innovation. 🚀

---

Angular Interview Preparation Guide for Experienced Developers

Angular has evolved into one of the most powerful front-end frameworks for building modern, scalable, and enterprise-level applications. For developers of experienced, interviews not only test your **theoretical knowledge** but also your **hands-on expertise** in building, deploying, and maintaining real-world Angular applications.

In this article, we’ll walk through the **key areas in Angular** you should master — starting from fundamentals to advanced production-ready concepts.

## 1. Angular Lifecycle Hooks

Lifecycle hooks are crucial for managing component creation, rendering, and destruction. Be prepared to explain **when and why** to use them.

* **ngOnInit**: Initialize component data.

* **ngOnChanges**: Detect changes in input-bound properties.

* **ngDoCheck**: Custom change detection.

* **ngAfterViewInit & ngAfterContentInit**: DOM and content initialization.

* **ngOnDestroy**: Cleanup, unsubscribe from Observables, release resources.

👉 **Interview Tip**: Be ready with real-time scenarios like unsubscribing in `ngOnDestroy` to prevent memory leaks.

## 2. Routing & Navigation

Routing is the backbone of any Angular application. Understand:

* **RouterModule** setup with `forRoot()` and `forChild()`.

* **Lazy Loading** modules for performance optimization.

* **Child Routes & Wildcards** (`**` for 404 pages).

* **Route Guards** (AuthGuard, CanActivate, CanDeactivate, Resolve).

* **Preloading strategies** for balancing lazy loading with speed.

👉 Example: Use `AuthGuard` with JWT tokens to restrict access to secure routes.

## 3. Forms in Angular

Forms are everywhere in enterprise apps. You must be comfortable with both approaches:

* **Template-driven forms** (simple, quick setup, two-way binding).

* **Reactive forms** (more control, validation, and scalability).

Key concepts:

* FormControl, FormGroup, FormBuilder.

* Built-in and custom validators.

* Async validators (e.g., checking if a username already exists).

* Dynamic form generation.

## 4. Angular Material & UI Components

Angular Material provides ready-to-use UI components. Focus on:

* Data tables with sorting, pagination, filtering.

* Dialogs, snackbars, and modals.

* Responsive layouts using Flex Layout/Grid.

* Theming and customization.

👉 **Interview Tip**: Be able to explain how Angular Material improves productivity and consistency.

## 5. Dependency Injection (DI)

Angular’s DI system is core to writing maintainable code. Know:

* Provider scopes: root, feature module, component.

* Hierarchical injectors.

* `@Injectable({ providedIn: 'root' })` usage.

* Tree-shakable providers.

* Use cases of `InjectionToken`.

## 6. HTTP Interceptors & API Handling

Interceptors allow you to **modify requests/responses globally**. Key scenarios:

* Attaching **JWT tokens** to headers.

* Global error handling (e.g., redirect to login on `401 Unauthorized`).

* Request/response logging.

* Caching responses for performance.

## 7. Authentication & Authorization (JWT Implementation)

Almost every production app requires authentication. Learn how to:

* Store and manage JWT tokens securely (localStorage vs cookies).

* Refresh tokens.

* Use interceptors to attach tokens.

* Protect routes with AuthGuards.

* Role-based access control.

👉 **Hands-on Task**: Implement login/logout with JWT, refresh tokens, and secure route navigation.

## 8. Caching & Performance Optimization

Production-grade apps demand speed. Interviewers expect knowledge of:

* Browser caching strategies (LocalStorage, IndexedDB).

* API response caching via interceptors.

* `OnPush` change detection strategy.

* Lazy loading and preloading strategies.

* TrackBy with `*ngFor` to prevent re-rendering.

## 9. Server-Side Rendering (SSR) with Angular Universal

For SEO and performance, Angular Universal is important. Be ready to answer:

* How SSR improves **SEO** for Angular apps.

* Setting up Angular Universal.

* Handling API calls on the server vs client.

* Differences between CSR (Client-Side Rendering) and SSR.

## 10. Error Handling & Logging

Enterprise apps need solid error handling. Know how to:

* Use **ErrorHandler** class for global error handling.

* Implement custom error services.

* Log errors to monitoring tools (e.g., Sentry, Azure App Insights).

* Show user-friendly error messages.

## 11. State Management (NgRx / Services)

Large apps often use state management. You should:

* Understand RxJS and Observables deeply.

* Be able to explain state management with Services and BehaviorSubject.

* Know NgRx basics: Actions, Reducers, Effects, Store.

* When to choose NgRx vs simple service-based state management.

## 12. Production-Level Deployment

Finally, demonstrate deployment expertise:

* `ng build --prod` optimizations (AOT compilation, minification, tree-shaking).

* Hosting on **Azure, AWS, Firebase, or Nginx**.

* Environment configuration (`environment.ts`).

* CI/CD pipeline setup for Angular apps.

* Handling SSL, security headers, and API proxy configuration.

## Conclusion

For a experienced Angular developer, interviews focus less on syntax and more on **architecture, scalability, performance, and deployment**.

If you cover these areas thoroughly — from lifecycle hooks, routing, forms, interceptors, JWT, Angular Universal, to production deployment — you’ll not only crack interviews but also be confident in building enterprise-grade Angular applications.

✅ **Pro Tip**: Build a small end-to-end Angular project that includes authentication, lazy loading, caching, Angular Material UI, and SSR. This will help you confidently explain your real-world experience.