DEV Community: Bassem Hussein

Building a Scalable Audit Log System with AWS Serverless Services (No Lambda)

Bassem Hussein — Wed, 03 Jun 2026 20:32:03 +0000

Introduction

Audit logging is a critical requirement for any enterprise system — you need to know who did what, when, and to which entity. But building an audit log system that scales with your microservices architecture without breaking the bank is challenging.

In this post, we walk through how we built a production-grade, cost-optimized audit logging pipeline on AWS that captures domain events from multiple microservices and makes them queryable via SQL — all without a single Lambda function or server to manage.

The Problem

We have dozens of microservices (orders, inventory, users, etc.) that modify entities like Orders, Order Items, and User Accounts. We needed:

Complete audit trail — every create, update, and delete captured
Parent-child relationships — e.g., an OrderItem belongs to an Order
Fast, cheap queries — filter by date, source, entity, actor
Zero operational overhead — no servers, no scaling concerns
SQL injection protection — safe querying from application code

Architecture

┌──────────────────────┐
│   Microservices      │
│  (Orders, Inventory, │
│   Users, etc.)       │
└──────────┬───────────┘
           │ PutEvents
           ▼
┌──────────────────────┐
│  Amazon EventBridge  │
│  (Central Event Bus) │
└──────────┬───────────┘
           │ Rule → Target
           ▼
┌──────────────────────┐
│  Kinesis Firehose    │
│  (Buffer + Compress) │
└──────────┬───────────┘
           │ GZIP → S3
           ▼
┌──────────────────────┐
│  S3 (Raw Layer)      │
│  year=YYYY/month=MM/ │
│  day=DD/hour=HH/     │
└──────────┬───────────┘
           │ Daily Schedule
           ▼
┌──────────────────────┐
│  AWS Glue ETL        │
│  (PySpark → Parquet) │
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│  S3 (Analytics)      │
│  dt=YYYY-MM-DD/      │
│  source=service/     │
└──────────┬───────────┘
           │
           ▼
┌──────────────────────┐
│  Amazon Athena       │
│  (Serverless SQL)    │
└──────────────────────┘

Why No Lambda?

Most audit log implementations use Lambda to transform events in real-time. We intentionally avoided this:

Concern	Lambda Approach	Our Approach (Glue)
Cost at scale	Per-invocation billing adds up	Single daily job, fixed cost
Cold starts	Adds latency	N/A — batch processing
Concurrency limits	Can throttle under load	No limits
Error handling	Complex DLQ patterns	Simple retry on daily job
Transformation bugs	Break real-time ingestion	Fix and re-run the batch

Key insight: Audit logs don't need real-time transformation. A daily batch is cheaper, simpler, and equally useful for compliance and investigation.

Step 1: Event Publishing (Microservices)

Each microservice publishes domain events to EventBridge following a consistent contract:

{
  "source": "myapp.orderservice",
  "detail-type": "orderitemupdated.v1",
  "time": "2026-04-02T12:31:01Z",
  "detail": {
    "entities": [
      {
        "entity": {
          "id": "1001",
          "name": "Order Item #1001",
          "status": "Processing"
        },
        "before": {
          "quantity": "2",
          "status": "Pending"
        },
        "after": {
          "quantity": "5",
          "status": "Processing"
        },
        "parent": {
          "id": "500",
          "name": "Order #500",
          "type": "Order"
        },
        "channel_code": "WEB",
        "channel_account_code": "Primary"
      }
    ],
    "entity_type": "OrderItem",
    "action": "Update",
    "correlation_id": "40f12582-b3be-4aeb-a7ca-9d9247030e20",
    "actor": {
      "type": 1,
      "name": "jane@example.com"
    }
  }
}

Design Rules

entity is the only required object — it must have id and name
before and after are optional JSON maps (missing = no change tracking)
parent is optional — supports hierarchical entity relationships
channel_code and channel_account_code are optional strings
actor.type: 0 = Service, 1 = User, 2 = Client

This contract is generic enough that any microservice can publish events without custom schemas.

Step 2: EventBridge to Firehose (Zero Code)

An EventBridge rule routes matching events directly to a Kinesis Firehose delivery stream. No Lambda in between.

# CloudFormation snippet
AuditLogRule:
  Type: AWS::Events::Rule
  Properties:
    EventBusName: myapp-eventbus
    EventPattern:
      source:
        - prefix: "myapp"
    Targets:
      - Id: FirehoseTarget
        Arn: !GetAtt DeliveryStream.Arn
        RoleArn: !GetAtt EventBridgeRole.Arn

Firehose buffers events (60 seconds or 5 MB, whichever comes first) and writes them as GZIP-compressed JSON to S3.

Step 3: Raw Storage (S3)

Raw events land in a time-partitioned structure:

s3://myapp-audit-logs-bucket/raw/eventbridge/
  year=2026/month=05/day=01/hour=15/
    firehose-1-2026-05-01-15-00-00.json.gz

This layer is:

Cheap — GZIP compressed, short retention
Not queried directly — exists only as input for Glue
Lifecycle managed — transitions to Glacier after 30 days, expires after 90

Step 4: Glue ETL (Daily Transformation)

A scheduled AWS Glue job runs daily and transforms yesterday's raw events into query-optimized Parquet:

import pyspark.sql.functions as F
from pyspark.sql.types import *
from awsglue.context import GlueContext

# Read yesterday's raw JSON
raw_df = spark.read.json(f"s3://{bucket}/raw/eventbridge/year={y}/month={m}/day={d}/")

# Extract detail and explode entities array
detail_df = raw_df.select(
    F.col("id").alias("EventId"),
    F.col("time").alias("Timestamp"),
    F.col("source").alias("Source"),
    F.col("detail.actor.name").alias("ActorName"),
    F.col("detail.actor.type").alias("ActorType"),
    F.col("detail.entity_type").alias("EntityType"),
    F.col("detail.action").alias("Action"),
    F.col("detail.correlation_id").alias("CorrelationId"),
    F.explode("detail.entities").alias("entity_change")
)

# Extract entity fields (always present)
result_df = detail_df.select(
    "*",
    F.col("entity_change.entity.id").cast("string").alias("EntityId"),
    F.col("entity_change.entity.name").alias("EntityName"),
    # Parent fields (optional - coalesce handles missing)
    F.coalesce(F.col("entity_change.parent.id").cast("string"), F.lit(None)).alias("EntityParentId"),
    F.coalesce(F.col("entity_change.parent.name"), F.lit(None)).alias("EntityParentName"),
    F.coalesce(F.col("entity_change.parent.type"), F.lit(None)).alias("EntityParentType"),
    # Optional context strings
    F.coalesce(F.col("entity_change.channel_code"), F.lit(None)).alias("ChannelCode"),
    F.coalesce(F.col("entity_change.channel_account_code"), F.lit(None)).alias("ChannelAccountCode"),
    # Before/After as JSON strings
    F.to_json(F.col("entity_change.before")).alias("Before"),
    F.to_json(F.col("entity_change.after")).alias("After"),
)

# Write partitioned Parquet
result_df.write \
    .mode("overwrite") \
    .partitionBy("dt", "source") \
    .parquet(f"s3://{bucket}/analytics/auditlog_parquet/")

Key Points

F.coalesce(..., F.lit(None)) — gracefully handles missing parent, channel_code, etc.
F.explode("detail.entities") — one event can produce multiple audit rows
Parquet format — columnar, compressed, perfect for Athena
Partitioned by dt and source — enables partition pruning

Step 5: Athena Table (Serverless SQL)

The Athena table uses partition projection — no crawlers, no MSCK REPAIR TABLE:

CREATE EXTERNAL TABLE audit_logs_db.auditlog (
  Id string,
  Timestamp timestamp,
  ActorName string,
  ActorType string,
  EntityId string,
  EntityName string,
  EntityType string,
  EntityParentId string,
  EntityParentName string,
  EntityParentType string,
  ChannelCode string,
  ChannelAccountCode string,
  Action string,
  Before string,
  After string,
  CorrelationId string
)
PARTITIONED BY (dt string, source string)
STORED AS PARQUET
LOCATION 's3://myapp-audit-logs-bucket/analytics/auditlog_parquet/'
TBLPROPERTIES (
  'projection.enabled' = 'true',
  'projection.dt.type' = 'date',
  'projection.dt.range' = '2024-01-01,NOW',
  'projection.dt.format' = 'yyyy-MM-dd',
  'projection.dt.interval' = '1',
  'projection.dt.interval.unit' = 'DAYS',
  'projection.source.type' = 'injected',
  'storage.location.template' = 's3://myapp-audit-logs-bucket/analytics/auditlog_parquet/dt=${dt}/source=${source}/'
);

Example Queries

-- All updates by a specific user in the last week
SELECT *
FROM audit_logs_db.auditlog
WHERE dt >= '2026-05-27'
  AND source = 'myapp.orderservice'
  AND ActorName = 'jane@example.com'
  AND Action = 'Update'
ORDER BY Timestamp DESC
LIMIT 100;

-- All changes to an Order and its child OrderItems
SELECT *
FROM audit_logs_db.auditlog
WHERE dt >= '2026-05-11' AND dt <= '2026-05-18'
  AND source IN ('myapp.orderservice', 'myapp.inventoryservice')
  AND (EntityId = '500' OR EntityParentId = '500')
ORDER BY Timestamp DESC;

Step 6: C# Client Library (NuGet Package)

We built a strongly-typed client that generates safe SQL and handles pagination:

Installation

dotnet add package MyApp.AuditLogs

Setup

services.AddAuditLogAthena(options =>
{
    options.Database = "audit_logs_db";
    options.Table = "auditlog";
    options.OutputLocation = "s3://athena-results-bucket/";
    options.WorkGroup = "primary";
});

Querying

var page = await client.QueryAsync(new AuditLogQuery
{
    From = DateOnly.FromDateTime(DateTime.UtcNow.AddDays(-7)),
    To = DateOnly.FromDateTime(DateTime.UtcNow),
    Sources = new[] { "myapp.orderservice" },
    Limit = 100,
    EntityId = "500",
    IncludeChildren = true,  // Also fetches child entities (e.g. OrderItems)
    EntityTypes = new[] { "Order" },
    Actions = new[] { Action.Update }
});

// Paginate
if (page.NextCursor != null)
{
    var nextPage = await client.QueryAsync(new AuditLogQuery
    {
        // ... same filters ...
        Cursor = page.NextCursor,
        Direction = PageDirection.Next
    });
}

Security

Since Athena doesn't support parameterized queries, the client implements:

Input validation — max string length, date range limits (7 days max)
SQL escaping — single quotes doubled (O'Brien → O''Brien)
Type-safe enums — ActorType and Action prevent arbitrary injection
Limit enforcement — max 1000 rows per query

Cost Breakdown

For a system processing ~100K events/day:

Service	Monthly Cost	Notes
EventBridge	~$3	$1/million events
Firehose	~$0.15	$0.029/GB × ~5GB/month
S3 (Raw)	~$0.12	Short retention, GZIP
S3 (Parquet)	~$0.05	Columnar, compressed
Glue	~$13	1 DPU × 30 min/day
Athena	~$0.50	Partition pruning, Parquet
Total	~$17/month

Compare this to running an always-on database or Elasticsearch cluster ($100-500+/month).

Deployment (GitHub Actions + OIDC)

We deploy using GitHub Actions with OIDC authentication — no long-lived AWS credentials:

name: Deploy Audit Logs

on:
  push:
    branches: [main]

permissions:
  id-token: write
  contents: read

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: ${{ secrets.DEPLOY_ROLE }}
          aws-region: us-east-1

      - name: Deploy CloudFormation
        run: |
          aws cloudformation deploy \
            --template-file aws/cf.yaml \
            --stack-name audit-logs-pipeline \
            --capabilities CAPABILITY_IAM

Lessons Learned

1. Not Everything Needs Real-Time Processing

Audit logs are written once and read occasionally. Daily batch transformation is perfectly adequate and dramatically cheaper than real-time Lambda processing.

2. Partition Projection Eliminates Operational Toil

Without partition projection, every new day requires running MSCK REPAIR TABLE or a Glue Crawler. Partition projection handles this automatically.

3. Make Optional Fields Truly Optional

The parent, channel_code, and before/after fields are all optional in our schema. The Glue job uses F.coalesce() to gracefully handle missing data — no event is ever rejected.

4. Composite Cursors Handle Duplicate Timestamps

Using Timestamp + Id as a pagination cursor ensures stable ordering even when multiple events share the same timestamp.

5. Validate at the Query Layer

Since Athena doesn't support parameterized queries, input validation and escaping in the client library is critical. We enforce max date ranges (7 days) to prevent expensive full-table scans.

Summary

By combining EventBridge, Firehose, S3, Glue, and Athena — and intentionally avoiding Lambda — we built a production audit log system that:

✅ Scales automatically with event volume

✅ Costs ~$17/month for 100K events/day

✅ Supports hierarchical entity queries (parent-child)

✅ Provides cursor-based pagination for frontend integration

✅ Protects against SQL injection

✅ Handles optional fields gracefully

✅ Deploys with zero long-lived credentials

The key takeaway: choose the right tool for the job. For audit logs, a daily batch with Parquet + Athena beats a real-time Lambda pipeline on cost, simplicity, and reliability.

🕒 Automating Periodic Tasks with EventBridge Scheduler, .NET, and CloudFormation

Bassem Hussein — Mon, 27 Oct 2025 21:35:10 +0000

Many applications need to perform tasks on a recurring schedule — refreshing data, syncing APIs, or cleaning up records. Instead of managing EC2 cron jobs or containers, AWS gives you a fully managed option: Amazon EventBridge Scheduler.

In this post, we’ll build a simple proof of concept (POC) showing how to trigger a .NET Lambda function on a schedule using AWS CloudFormation.

We’ll also discuss what to do if your job takes longer than the Lambda time limit of 15 minutes.

🧩 What You’ll Build

You’ll deploy:

A .NET 8 Lambda function that simulates fetching stock prices
A CloudFormation template that defines:
- The Lambda function and its IAM role
- An EventBridge Scheduler that runs every 10 minutes
- An SQS Dead Letter Queue (DLQ) for failed invocations

Here’s the architecture:

⚙️ Step 1. Create a .NET Lambda Function

Start by creating a simple .NET 8 Lambda that logs a simulated stock price.

🧱 Project Setup

dotnet new lambda.empty-function -n StockPriceUpdater
cd StockPriceUpdater

🧠 Function Code (`Function.cs`)

using System.Text.Json;
using Amazon.Lambda.Core;

[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace StockPriceUpdater;

public class ScheduledJobInput
{
    public string JobType { get; set; } = string.Empty;
    public object? Payload { get; set; }
}

public class Payload
{
    public string AccountCode { get; set; } = string.Empty;
}

public class Function
{
    public async Task InvokeAsync(ScheduledJobInput input, ILambdaContext context)
    {
        context.Logger.LogLine($"[StockPriceUpdater] Triggered for JobType: {input.JobType}");

        if (input.Payload is JsonElement payloadJson)
        {
            var payload = payloadJson.Deserialize<Payload>();
            context.Logger.LogLine($"AccountCode: {payload?.AccountCode}");
        }

        await UpdateStockPricesAsync(input.JobType);
    }

    private Task UpdateStockPricesAsync(string jobType)
    {
        var price = Math.Round(new Random().NextDouble() * 100, 2);
        Console.WriteLine($"[{jobType}] Simulated stock price: ${price} at {DateTime.UtcNow:O}");
        return Task.CompletedTask;
    }
}

This function accepts a small JSON payload and logs a random “stock price.”

It’s a simple stand-in for any periodic background task you might need.

📜 Step 2. Deploy with CloudFormation

Save the following as stock-price-updater.yml:

AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda triggered by EventBridge Scheduler for periodic stock updates

Parameters:
  ResourcePrefix:
    Type: String
    Default: stock-updater
  LambdaCodeBucket:
    Type: String
    Description: S3 bucket where Lambda zip is stored
  LambdaCodeKey:
    Type: String
    Description: Key (file name) of Lambda zip in S3

Resources:
  ##################################################
  # IAM Role for Lambda
  ##################################################
  StockPriceUpdaterRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${ResourcePrefix}-lambda-role"
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

  ##################################################
  # Lambda Function
  ##################################################
  StockPriceUpdaterFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: !Sub "${ResourcePrefix}-function"
      Handler: StockPriceUpdater::StockPriceUpdater.Function::InvokeAsync
      Role: !GetAtt StockPriceUpdaterRole.Arn
      Runtime: dotnet8
      Timeout: 600 # 10 minutes (max is 900 = 15 minutes)
      MemorySize: 512
      Code:
        S3Bucket: !Ref LambdaCodeBucket
        S3Key: !Ref LambdaCodeKey

  ##################################################
  # Dead Letter Queue (DLQ)
  ##################################################
  StockPriceUpdaterDLQ:
    Type: AWS::SQS::Queue
    Properties:
      QueueName: !Sub "${ResourcePrefix}-dlq"
      MessageRetentionPeriod: 1209600 # 14 days

  ##################################################
  # Role for EventBridge Scheduler
  ##################################################
  SchedulerInvokeRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${ResourcePrefix}-scheduler-role"
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: "Allow"
            Principal:
              Service: "scheduler.amazonaws.com"
            Action: "sts:AssumeRole"
      Policies:
        - PolicyName: SchedulerInvokeLambdaAndDLQ
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: "Allow"
                Action: "lambda:InvokeFunction"
                Resource: !GetAtt StockPriceUpdaterFunction.Arn
              - Effect: "Allow"
                Action: "sqs:SendMessage"
                Resource: !GetAtt StockPriceUpdaterDLQ.Arn

  ##################################################
  # EventBridge Scheduler
  ##################################################
  StockPriceUpdaterSchedule:
    Type: AWS::Scheduler::Schedule
    Properties:
      Name: !Sub "${ResourcePrefix}-scheduler"
      Description: "Triggers the Lambda every 10 minutes"
      FlexibleTimeWindow:
        Mode: "OFF"
      ScheduleExpression: "rate(10 minutes)"
      State: "ENABLED"
      Target:
        Arn: !GetAtt StockPriceUpdaterFunction.Arn
        RoleArn: !GetAtt SchedulerInvokeRole.Arn
        DeadLetterConfig:
          Arn: !GetAtt StockPriceUpdaterDLQ.Arn
        Input: |
          {
            "JobType": "StockUpdate",
            "Payload": { "AccountCode": "Primary" }
          }

Outputs:
  LambdaFunctionName:
    Value: !Ref StockPriceUpdaterFunction
    Description: Name of the Lambda function

🚀 Step 3. Package and Deploy

Package the Lambda

dotnet lambda package --output-package ./StockPriceUpdater.zip
aws s3 cp ./StockPriceUpdater.zip s3://your-bucket/

Deploy the stack

aws cloudformation deploy \
  --template-file stock-price-updater.yml \
  --stack-name StockPriceUpdater \
  --capabilities CAPABILITY_IAM \
  --parameter-overrides \
      ResourcePrefix=stock-updater \
      LambdaCodeBucket=your-bucket \
      LambdaCodeKey=StockPriceUpdater.zip

🧾 Step 4. Verify It Works

After deployment:

Go to Amazon EventBridge → Scheduler → Schedules — you’ll see one schedule.
Open CloudWatch Logs for your Lambda and verify logs every 10 minutes:

[StockPriceUpdater] Triggered for JobType: StockUpdate
AccountCode: Primary
[StockUpdate] Simulated stock price: $74.82 at 2025-10-27T09:00:00Z

Failures are sent automatically to the DLQ (SQS).

⚠️ Lambda Execution Time Limit (15 Minutes)

AWS Lambda has a hard timeout limit of 15 minutes per execution.

If your background job might exceed this:

Step Functions: Chain multiple Lambdas or tasks with retries and parallel steps.
AWS Fargate: Run containerized tasks without worrying about execution time.
AWS Batch: Run large-scale batch jobs with automatic compute scaling.

For long-running tasks, replace Lambda with Step Functions, Fargate, or Batch triggered by EventBridge Scheduler.

🧭 Wrapping Up

You learned how to:

Use EventBridge Scheduler to trigger a .NET Lambda periodically
Handle failures with an SQS DLQ
Deploy everything with CloudFormation

This approach is serverless, scalable, and fully managed, ideal for background jobs, periodic updates, or monitoring tasks.

✅ Key Takeaways

Feature	Description
EventBridge Scheduler	Replaces cron jobs with a managed scheduler
Lambda	Ideal for short, frequent tasks
DLQ (SQS)	Captures failed events for later inspection
CloudFormation	Declarative, repeatable deployments
Limit	Max Lambda duration = 15 minutes — use Step Functions, Fargate, or Batch for longer jobs

Building a Product Entity CRUD Application in Spring Boot for .NET Developers

Bassem Hussein — Thu, 02 Jan 2025 16:14:06 +0000

After exploring the basics of Spring Boot 3 in the previous post, let’s dive deeper by implementing a Product entity CRUD (Create, Read, Update, Delete) operation. Along the way, we’ll compare core Spring Boot concepts with their .NET Core counterparts to help bridge the gap for .NET developers transitioning to the Java ecosystem.

Setting Up the Project

Before starting, ensure you have a Spring Boot project ready with the following dependencies:

Spring Web: For building REST APIs.
Spring Data JPA: For database interactions.
PostgreSQL Driver: For connecting to a PostgreSQL database.

Run PostgreSQL Locally Using Docker

To run PostgreSQL locally, use Docker to quickly set up an instance:

Pull the PostgreSQL image:
```
docker pull postgres
```

Run a PostgreSQL container:

docker run --name postgres-db -e POSTGRES_PASSWORD=yourpassword -e POSTGRES_USER=yourusername -e POSTGRES_DB=mydatabase -p 5432:5432 -d postgres

Replace yourusername, yourpassword, and mydatabase with your desired username, password, and database name.

Verify the database is running:
```
docker ps
```
Use a database client (e.g., DBeaver, pgAdmin, or psql) to connect to localhost:5432 and verify your database is accessible.

Update the `pom.xml` File

If you are using Maven, include the following dependencies in your pom.xml file to ensure all necessary libraries are available:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.5.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Also, ensure the following plugin is included for building the project:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Comparison with .NET Core:
In .NET Core, package references are managed using the csproj file. Equivalent dependencies for a PostgreSQL-backed web API might look like this:

<ItemGroup>
  <PackageReference Include="Microsoft.AspNetCore.App" />
  <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.0" />
</ItemGroup>

Configure PostgreSQL Database

Update your application.yml file to connect to a PostgreSQL database:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydatabase
    username: yourusername
    password: yourpassword
  jpa:
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: update

Replace mydatabase, yourusername, and yourpassword with your actual PostgreSQL database details. The ddl-auto=update setting ensures that Hibernate creates or updates tables automatically based on your entity definitions.

Comparison with .NET Core:
In .NET Core, similar configurations would reside in appsettings.json:

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=mydatabase;Username=yourusername;Password=yourpassword"
  },
  "EntityFramework": {
    "MigrationsAssembly": "YourProjectName"
  }
}

Project Structure Overview

Spring Boot projects organize code into packages:

entity: Contains data models.
repository: Interfaces for database operations.
controller: REST endpoints.
service (optional): Business logic.

This structure is similar to the typical layers in a .NET Core project: Models, Data/Repositories, Controllers, and Services.

Step 1: Define the Product Entity

In Spring Boot, entities represent database tables, similar to models in Entity Framework Core. Use annotations like @Entity and @Id to map the class to a table:

package com.example.demo.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String description;
    private Double price;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

.NET Core Equivalent

public class Product
{
    public long Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public double Price { get; set; }
}

Step 2: Create a Repository

In Spring Boot, repositories are interfaces extending JpaRepository. They provide built-in CRUD operations, akin to DbContext in EF Core.

package com.example.demo.repository;

import com.example.demo.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

.NET Core Equivalent

public class ProductRepository
{
    private readonly DbContext _context;

    public ProductRepository(DbContext context)
    {
        _context = context;
    }

    public async Task<List<Product>> GetAllAsync() => await _context.Products.ToListAsync();

    // Other CRUD methods
}

Step 3: Implement a Service Layer (Optional)

The service layer handles business logic. While optional, it’s a good practice for larger applications.

package com.example.demo.service;

import com.example.demo.entity.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Optional<Product> getProductById(Long id) {
        return productRepository.findById(id);
    }

    public Product saveProduct(Product product) {
        return productRepository.save(product);
    }

    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
}

.NET Core Equivalent

public class ProductService
{
    private readonly ProductRepository _repository;

    public ProductService(ProductRepository repository)
    {
        _repository = repository;
    }

    public async Task<List<Product>> GetAllProductsAsync() => await _repository.GetAllAsync();

    // Other methods
}

Step 4: Build the Controller

Controllers handle HTTP requests, just like in ASP.NET Core.

package com.example.demo.controller;

import com.example.demo.entity.Product;
import com.example.demo.service.ProductService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Optional<Product> product = productService.getProductById(id);
        return product.map(ResponseEntity::ok).orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return productService.saveProduct(product);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
        return ResponseEntity.noContent().build();
    }
}

.NET Core Equivalent

[ApiController]
[Route("api/products")]
public class ProductController : ControllerBase
{
    private readonly ProductService _service;

    public ProductController(ProductService service)
    {
        _service = service;
    }

    [HttpGet]
    public async Task<IActionResult> GetAllProducts() => Ok(await _service.GetAllProductsAsync());

    [HttpGet("{id}")]
    public async Task<IActionResult> GetProductById(long id)
    {
        var product = await _service.GetProductByIdAsync(id);
        return product == null ? NotFound() : Ok(product);
    }

    [HttpPost]
    public async Task<IActionResult> CreateProduct([FromBody] Product product)
    {
        var createdProduct = await _service.SaveProductAsync(product);
        return CreatedAtAction(nameof(GetProductById), new { id = createdProduct.Id }, createdProduct);
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteProduct(long id)
    {
        await _service.DeleteProductAsync(id);
        return NoContent();
    }
}

Step 5: Testing Your API

Run your application and test the endpoints using tools like Postman or cURL. Ensure your PostgreSQL database is running and properly configured.

Once the application is up and running, test the CRUD endpoints with Postman or cURL. Ensure PostgreSQL is running and correctly configured.

Testing Endpoints with Postman:

GET /api/products: Fetch all products.
GET /api/products/{id}: Fetch a single product by ID.
POST /api/products: Create a new product.
DELETE /api/products/{id}: Delete a product by ID.

Key Comparisons

Feature	Spring Boot 3	.NET Core
Dependency Injection	Built-in with `@Autowired` or constructor injection	Built-in with `AddScoped`, `AddSingleton`
ORM Tool	Spring Data JPA	Entity Framework Core
Routing	`@RequestMapping`, `@GetMapping`	`[Route]`, `[HttpGet]`
Middleware	Spring Interceptors	ASP.NET Middleware
Response Handling	`ResponseEntity`	IActionResult

Conclusion

Creating a CRUD application in Spring Boot is simple, especially for those familiar with .NET Core. The principles of dependency injection, ORM, and RESTful APIs are similar in both ecosystems. This guide is just the start—future posts will cover Lombok integration, Swagger/OpenAPI, validation, error handling, and database migrations. Stay tuned!

Happy coding!

References

Spring Boot Documentation: https://spring.io/projects/spring-boot
PostgreSQL Documentation: https://www.postgresql.org/docs/
Spring Data JPA Documentation: https://spring.io/projects/spring-data-jpa
.NET Core Documentation: https://docs.microsoft.com/en-us/aspnet/core/?view=aspnetcore-7.0

Getting Started with Spring Boot 3 for .NET Developers

Bassem Hussein — Mon, 30 Dec 2024 12:24:16 +0000

Here is a list of following posts

Building a Product Entity CRUD Application in Spring Boot

I have been working with .NET since 2008; however, I recently started working in a team that primarily uses Java as the standard back-end language. Transitioning from .NET to Java can be both exciting and challenging.

For this guide, you’ll need some basic knowledge of Java to get started.

Spring Boot 3, a popular framework for building Java applications, offers many similarities to .NET frameworks like .NET Core. This guide will help you bridge the gap and take your first steps into the Spring Boot ecosystem.

Why Spring Boot 3?

Spring Boot 3 simplifies Java application development, just like ASP.NET Core does for .NET. Here’s why it might intrigue you:

Minimal Configuration: Opinionated defaults for rapid development.
Native Support: Build lightweight, native executables with GraalVM.
Wide Adoption: A mature ecosystem with robust libraries and tools.
Java 17+: Leverages modern Java features, much like how .NET embraces modern C#.

Step 1: Set Up Your Environment

Ensure you have the following:

Java 17 or later: Spring Boot 3 requires it. Think of it as the .NET 6 equivalent.
Maven or Gradle: Build tools similar to MSBuild.
An IDE like IntelliJ IDEA (similar to Visual Studio).

Verify your Java installation by running:

java -version

Step 2: Create a New Spring Boot Project

Spring Boot projects are typically initialized through Spring Initializr (akin to the .NET CLI project templates).

Option 1: Using Spring Initializr

Visit Spring Initializr.
Select:
- Project: Maven or Gradle (like choosing NuGet).
- Language: Java.
- Spring Boot Version: 3.x.x.
Add dependencies:
- Spring Web: Equivalent to ASP.NET Core for building REST APIs.
- Spring Data JPA: Similar to Entity Framework Core for database interactions.
- Spring Boot DevTools: Like Hot Reload in Visual Studio.
Download and import the project into IntelliJ or Eclipse.

Option 2: Use Your IDE

Many IDEs support project initialization directly, similar to creating a new project in Visual Studio.

Step 3: Explore the Project Structure

Here’s how a typical Spring Boot project maps to a .NET Core project:

src/main/java: Contains your controllers, services, and entities. Equivalent to the Controllers, Models, and Services folders in ASP.NET.
src/main/resources: Configuration files like application.properties. Think of it like appsettings.json.
pom.xml or build.gradle: Manages dependencies, similar to .csproj.

Step 4: Build Your First REST API

Create a simple REST API in Spring Boot:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello from Spring Boot 3!";
    }
}

.NET Equivalent:

[ApiController]
[Route("[controller]")]
public class HelloController : ControllerBase
{
    [HttpGet("hello")]
    public IActionResult SayHello()
    {
        return Ok("Hello from ASP.NET Core!");
    }
}

Step 5: Run the Application

In Spring Boot, running the application is as simple as executing a command:

./mvnw spring-boot:run   # For Maven
./gradlew bootRun        # For Gradle

Navigate to http://localhost:8080/hello to see your API in action.

Step 6: Comparing Core Concepts

Here’s a quick comparison of familiar .NET Core concepts and their Spring Boot equivalents:

.NET Core Concept	Spring Boot Equivalent
ASP.NET Middleware	Spring Interceptors & Filters
Dependency Injection	Built-in DI Container
Entity Framework Core	Spring Data JPA
appsettings.json	application.properties or YAML
NuGet	Maven or Gradle

Step 7: Expand Your Application

Database Integration: Use Spring Data JPA to connect to a database, much like using EF Core.
Security: Add Spring Security for authentication and authorization, similar to ASP.NET Identity.
Observability: Use Spring Actuator for health checks and metrics, similar to .NET HealthChecks.

Step 8: Debugging and Hot Reload

Spring Boot’s DevTools provides hot-reloading, akin to .NET’s Hot Reload feature. Add spring-boot-devtools as a dependency to your project.

References

Spring Initializr: https://start.spring.io/
Spring Boot Documentation: https://docs.spring.io/spring-boot/docs/current/reference/html/
Java 17 Documentation: https://openjdk.org/projects/jdk/17/
Spring Framework 6: https://spring.io/projects/spring-framework
GraalVM Documentation: https://www.graalvm.org/
ASP.NET Core Overview: https://learn.microsoft.com/en-us/aspnet/core/

Conclusion

For .NET developers, learning Spring Boot 3 is a natural transition. Many concepts like dependency injection, REST APIs, and ORM tools are similar, allowing you to quickly adapt and leverage the strengths of the Java ecosystem.

I will create a series of posts following this guide to demonstrate how to put all these concepts into action by building a REST API for a product catalog. Stay tuned!

If you have any questions, I am glad to help.

Happy coding!

DEV Community: Bassem Hussein

Building a Scalable Audit Log System with AWS Serverless Services (No Lambda)

Introduction

The Problem

Architecture

Why No Lambda?

Step 1: Event Publishing (Microservices)

Design Rules

Step 2: EventBridge to Firehose (Zero Code)

Step 3: Raw Storage (S3)

Step 4: Glue ETL (Daily Transformation)

Key Points

Step 5: Athena Table (Serverless SQL)

Example Queries

Step 6: C# Client Library (NuGet Package)

Installation

Setup

Querying

Security

Cost Breakdown

Deployment (GitHub Actions + OIDC)

Lessons Learned

1. Not Everything Needs Real-Time Processing

2. Partition Projection Eliminates Operational Toil

3. Make Optional Fields Truly Optional

4. Composite Cursors Handle Duplicate Timestamps

5. Validate at the Query Layer

Summary

🕒 Automating Periodic Tasks with EventBridge Scheduler, .NET, and CloudFormation

🧩 What You’ll Build

⚙️ Step 1. Create a .NET Lambda Function

🧱 Project Setup

🧠 Function Code (Function.cs)

📜 Step 2. Deploy with CloudFormation

🚀 Step 3. Package and Deploy

🧾 Step 4. Verify It Works

⚠️ Lambda Execution Time Limit (15 Minutes)

🧭 Wrapping Up

✅ Key Takeaways

Building a Product Entity CRUD Application in Spring Boot for .NET Developers

Setting Up the Project

Run PostgreSQL Locally Using Docker

Update the pom.xml File

Configure PostgreSQL Database

Project Structure Overview

Step 1: Define the Product Entity

Step 2: Create a Repository

Step 3: Implement a Service Layer (Optional)

Step 4: Build the Controller

Step 5: Testing Your API

Testing Endpoints with Postman:

Key Comparisons

Conclusion

References

Getting Started with Spring Boot 3 for .NET Developers

Why Spring Boot 3?

Step 1: Set Up Your Environment

Step 2: Create a New Spring Boot Project

Option 1: Using Spring Initializr

Option 2: Use Your IDE

Step 3: Explore the Project Structure

Step 4: Build Your First REST API

Step 5: Run the Application

Step 6: Comparing Core Concepts

Step 7: Expand Your Application

Step 8: Debugging and Hot Reload

References

Conclusion

🧠 Function Code (`Function.cs`)

Update the `pom.xml` File