DEV Community: Leandro Marcos

Creating a Credit Analysis API with Azure Functions in Java

Leandro Marcos — Thu, 24 Jul 2025 21:11:27 +0000

🏦 Creating a Credit Analysis API with Azure Functions in Java

In this second article of our Azure Functions + Java series, you'll build a real and functional API that simulates a credit analysis, receiving client data and returning whether the credit is approved based on a randomly generated score.

📌 Didn’t read the introduction yet? Start here:

👉 Azure Functions with Java: When to Use, Pros, Limitations, and Triggers

🚀 What Are We Building?

We’re going to create an HTTP-based Azure Function that:

Receives a JSON payload with client name and desired amount
Generates a random credit score (from 0 to 1000)
Applies a rule: score ≥ 600 AND value ≤ 5000 = approved
Returns a JSON response with the result

💼 This use case is useful for:

Simulating a real-world credit scoring process
Testing microservices and APIs
Prototyping financial systems and flows

⚙️ Prerequisites

Java 17+
Maven
Azure CLI
Azure Function Core Tools

  npm install -g azure-functions-core-tools@4 --unsafe-perm true

📁 Creating the Project
Open your terminal and navigate to a folder that is not empty (e.g., C:\dev) and run:

mvn archetype:generate -DarchetypeGroupId=com.microsoft.azure -DarchetypeArtifactId=azure-functions-archetype -DgroupId=com.exemplo.fn -DartifactId=fn-analise-credito -Dversion=1.0-SNAPSHOT -Dpackage=com.exemplo.fn -DinteractiveMode=false -Darchetype.test=false

Tip: Do not run this command inside the destination folder (e.g., fn-analise-credito), or Maven will throw an error because it expects to create the folder from scratch.

🧹 Optional: Remove Unit Test Folder

By default, the generated project includes a src/test folder with a sample unit test. If you're not using unit tests at this stage, you can delete it with the following command:

🪟 For Windows (CMD or PowerShell):

Remove-Item -Recurse -Force .\src\test

🐧 For Linux or macOS:

rm -rf fn-analise-credito/src/test

💡 You can run this right after generating the project. It helps to keep the structure clean for simple proof-of-concept scenarios.

✍️ Coding the Credit Analysis Function

🔧 File: Function.java

package com.exemplo.fn;

import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;

import java.util.Optional;
import java.util.Random;

/**
 * Azure Function that simulates a credit analysis.
 */
public class Function {
    @FunctionName("analiseCredito")
    public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS)
        HttpRequestMessage<Optional<String>> request,
        final ExecutionContext context) {

        String body = request.getBody().orElse("");

        if (!body.contains("nome") || !body.contains("valor")) {
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
                .body("Missing required fields: 'nome' and 'valor'")
                .build();
        }

        String nome = extractValue(body, "nome");
        double valor = Double.parseDouble(extractValue(body, "valor").replace(",", "."));

        int score = new Random().nextInt(1001); // 0 to 1000
        boolean aprovado = score >= 600 && valor <= 5000;

        String responseJson = String.format(
            "{ \"cliente\": \"%s\", \"valor\": %.2f, \"score\": %d, \"aprovado\": %s }",
            nome, valor, score, aprovado
        );

        return request.createResponseBuilder(HttpStatus.OK)
            .header("Content-Type", "application/json")
            .body(responseJson)
            .build();
    }

    private String extractValue(String json, String key) {
        String[] parts = json.replace("\"", "").replace("{", "").replace("}", "").split(",");
        for (String part : parts) {
            if (part.trim().startsWith(key)) {
                return part.split(":")[1].trim();
            }
        }
        return "";
    }
}

📥 Example Request & Response

✅ Sample Input

{
  "nome": "Leandro",
  "valor": 3000
}

✅ Sample Response

{
  "cliente": "Leandro",
  "valor": 3000.00,
  "score": 712,
  "aprovado": true
}

▶️ Testing Locally

Compile and run the function:

mvn clean package
mvn azure-functions:run

Send a test request using Postman or curl:

curl -X POST "http://localhost:7071/api/analiseCredito" -H "Content-Type: application/json" -d "{ \"nome\": \"Leandro\", \"valor\": 3000 }"

You should receive a response with score and approval decision.

✅ Final Thoughts

In this article, you created a real-world Azure Function that:

Parses and validates JSON input
Applies business logic (credit score simulation)
Returns a formatted and dynamic JSON response

This is a solid foundation for building:

APIs
Cloud-native services
Event-driven systems

The full code and instructions are available on GitHub:
👉 leandrofmarcos/fn-credit-analysis-java

📚 Next in the Series

We’ll continue exploring Azure Functions with more real use cases using Java:

✅ Simulating Credit Analysis with Azure Functions in Java
🔜 Queue Trigger: Processing Tasks Asynchronously with Java
🔜 Blob Trigger: File Handling in Azure Storage
🔜 Durable Functions with Java: Orchestrating Workflows Serverlessly
🔜 Logging and Monitoring with Application Insights
🔜 Best Practices for Scalable and Maintainable Functions

❤️ Enjoyed This?

Leave a ❤️, drop a comment, or share this with your team or community.
Let’s show the world that Java and Azure Functions are a powerful combo in modern serverless architectures! 💻☁️

Azure Functions with Java

Leandro Marcos — Thu, 24 Jul 2025 20:27:57 +0000

☁️ Azure Functions with Java: When to Use, Pros, Limitations, and Triggers

Start your journey into the serverless universe by understanding what Azure Functions are, why and when to use them, the available triggers, pros, limitations, and how they fit into modern Java-based cloud architectures.

📌 What Are Azure Functions?

Azure Functions is Microsoft’s implementation of serverless computing, allowing you to run small blocks of code — called functions — without managing servers.

You write the code, define a trigger (an event that invokes the function), and Azure takes care of the rest:

Auto-scaling
Managed infrastructure
Global availability
Pay-per-execution billing

⚙️ How Does It Work?

An Azure Function is activated by events (HTTP request, timer, queue message, etc). It’s ideal for small and isolated operations like:

Processing files
Responding to HTTP requests
Consuming messages from queues
Automating scheduled tasks

Supported languages include:

Java
JavaScript / TypeScript
Python
C#
PowerShell, and more

🚀 Benefits

Benefit	Description
Serverless	No need to provision or manage servers
Auto-scaling	Scales automatically based on demand
Pay-per-execution	You only pay when your function is triggered
Deep Azure integration	Native support for Azure Storage, Queues, Cosmos DB, EventGrid, etc.
Multi-language support	Java support included
Simple deployment	Using Maven, Azure CLI, GitHub Actions, or Azure DevOps

⚠️ Limitations and Drawbacks

Limitation / Drawback	Description
Cold Start	First invocation may be slow in the Consumption plan
Execution Timeout	Limited to 5 minutes (extendable in Premium plans)
Stateless by default	Stateful flows require Durable Functions or external storage
Variable performance	Depends on your pricing plan and concurrency
Vendor lock-in	Strong coupling to the Azure ecosystem

🎯 When to Use Azure Functions?

Use it when:

✅ You need event-driven or on-demand lightweight tasks

✅ You want to scale fast and pay only for what you use

✅ You are integrating systems via queues, files, or APIs

✅ You need automated or scheduled background jobs

✅ You want to expose simple, stateless APIs

✅ You want to build decoupled and scalable pipelines

Avoid it when:

❌ You need long, synchronous operations (> 5–10 minutes)

❌ Your app demands ultra-low latency with consistent response times

❌ You want to avoid platform/vendor lock-in

❌ You need fine control over runtime, memory, or containers

🧩 Available Triggers

Azure Functions are event-driven. Here's a list of commonly used triggers:

Trigger Type	Description
HTTP Trigger	Responds to HTTP requests (GET, POST, etc.)
Timer Trigger	Runs on a defined schedule (cron-like)
Blob Trigger	Fires when files are added/changed in Azure Blob Storage
Queue Trigger	Runs when messages arrive in Azure Storage Queues
Service Bus Trigger	Runs on Service Bus message events
Event Grid Trigger	Responds to events from Storage, Event Hub, and more
Cosmos DB Trigger	Responds to changes in a Cosmos DB container
SignalR Trigger	Listens to SignalR connections/events

You can define multiple functions with different triggers in the same app.

🔁 What If I Need State? Use Durable Functions

Durable Functions is an extension that enables stateful workflows in a serverless model. It allows orchestration of long-running, multi-step processes.

Use it for:

Workflow coordination
Human interaction & approval steps
Retry and compensation logic
Delayed or scheduled executions

👨‍💻 What About Java?

Java is fully supported in Azure Functions with:

Maven build support
Local development with Azure Core Tools
Deployment via CLI, CI/CD, or Visual Studio Code

mvn clean package
mvn azure-functions:run

📚 Want a Real Example?

👉 In the next article, we'll create an Azure Function that simulates a credit analysis, receiving JSON data (name and amount), generating a random credit score, and responding whether the customer is approved or not.

📌 Create an Azure Function in Java That Simulates Credit Analysis

🧠 Conclusion

Azure Functions is a powerful, cost-efficient, and scalable solution to run code in response to events. With Java, you can use your backend experience to create real-world serverless applications — quickly and efficiently.

📦 Best for:

Integrations
Microservices APIs
Event pipelines
Scheduled jobs

But keep in mind: not every problem is serverless-shaped. Evaluate the use case carefully.

🗂️ Upcoming Articles in the Series

Create an Azure Function in Java That Simulates Credit Analysis
~~Queue Trigger: Processing Tasks Asynchronously with Java~~
~~Blob Trigger: File Handling in Azure Storage~~
~~Durable Functions with Java: Orchestrating Workflows Serverlessly~~
~~Logging and Monitoring with Application Insights~~
~~Best Practices for Scalable and Maintainable Functions~~

❤️ Enjoyed It?

Leave a ❤️, drop a comment, or share this with a fellow Java dev!

Let’s prove that Java and Azure Functions are a strong match in the serverless world!

Building a Resilient Exception Strategy with Apache Beam and DLQ

Leandro Marcos — Mon, 21 Jul 2025 20:58:34 +0000

Context: when the pipeline stops because of a single record

In a common large-scale data ingestion scenario using Apache Beam, we faced a classic issue: a single malformed record caused the entire pipeline to fail.

It was expected that some records might contain errors, but the pipeline was assuming everything would work perfectly. There was no fallback, no distinction between business or technical errors, and no isolation for problematic data.

This led us to the key question: how do we keep the pipeline healthy even in the presence of predictable failures?

What we needed to solve

Prevent exceptions from halting the processing of all data
Separate technical failures (e.g., API errors) from business logic issues (e.g., invalid value)
Log errors in a structured format for analysis and possible reprocessing
Implement controlled retry without infinite loops

Proposed Architecture

We implemented an approach based on:

ParDo with MultiOutputReceiver and TupleTag to separate data flows
try/catch for error classification
Retry with a max-attempt limit for technical failures
DLQ (Dead Letter Queue) with .jsonl files saved locally

Flow Diagram:

             +------------------+
             |  Incoming Data   |
             +------------------+
                      |
                      v
     +----------------------------------------+
     |    ParDo with Exception Handling       |
     +----------------------------------------+
        |                |                  |
        |                |                  |
        v                v                  v
+----------------+ +------------------+ +--------------------+
|  SUCCESS Path  | | Business Error   | | Technical Error    |
| Final Output   | | business_error.* | | technical_error.*  |
+----------------+ +------------------+ +--------------------+

Local Example with Apache Beam

Dependencies in `pom.xml`

<dependencies>
  <dependency>
    <groupId>org.apache.beam</groupId>
    <artifactId>beam-sdks-java-core</artifactId>
    <version>2.55.0</version>
  </dependency>
  <dependency>
    <groupId>org.apache.beam</groupId>
    <artifactId>beam-runners-direct-java</artifactId>
    <version>2.55.0</version>
  </dependency>
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>2.0.7</version>
  </dependency>
</dependencies>

`ExceptionHandlingPipeline.java`

package com.example.beam;

import org.apache.beam.sdk.Pipeline;
import org.apache.beam.sdk.io.TextIO;
import org.apache.beam.sdk.metrics.Counter;
import org.apache.beam.sdk.metrics.Metrics;
import org.apache.beam.sdk.transforms.*;
import org.apache.beam.sdk.values.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

public class ExceptionHandlingPipeline {

    private static final Logger LOG = LoggerFactory.getLogger(ExceptionHandlingPipeline.class);

    public static final TupleTag<String> BUSINESS_ERROR_TAG = new TupleTag<String>() {};
    public static final TupleTag<String> TECHNICAL_ERROR_TAG = new TupleTag<String>() {};
    public static final TupleTag<String> SUCCESS_TAG = new TupleTag<String>() {};

    public static void main(String[] args) {
        Pipeline p = Pipeline.create();

        List<String> inputs = Arrays.asList(
            "valid_data_1",
            "valid_data_2",
            "business_error",
            "technical_error",
            "unexpected_exception"
        );

        PCollectionTuple result = p.apply("Create Input", Create.of(inputs))
            .apply("Safe Transform", ParDo
                .of(new SafeProcessFn())
                .withOutputTags(SUCCESS_TAG, TupleTagList.of(BUSINESS_ERROR_TAG).and(TECHNICAL_ERROR_TAG)));

        result.get(SUCCESS_TAG)
              .apply("Write Success", TextIO.write().to("output/success").withSuffix(".txt").withoutSharding());

        result.get(BUSINESS_ERROR_TAG)
              .apply("Format Business Error", MapElements.via(new SimpleFunction<String, String>() {
                  public String apply(String input) {
                      return String.format("{\"timestamp\":\"%s\",\"input\":\"%s\",\"errorType\":\"BusinessError\"}",
                              Instant.now(), input);
                  }
              }))
              .apply(TextIO.write().to("dlq/business_error").withSuffix(".jsonl").withoutSharding());

        result.get(TECHNICAL_ERROR_TAG)
              .apply("Format Technical Error", MapElements.via(new SimpleFunction<String, String>() {
                  public String apply(String input) {
                      return String.format("{\"timestamp\":\"%s\",\"input\":\"%s\",\"errorType\":\"TechnicalError\"}",
                              Instant.now(), input);
                  }
              }))
              .apply(TextIO.write().to("dlq/technical_error").withSuffix(".jsonl").withoutSharding());

        p.run().waitUntilFinish();
    }

    static class SafeProcessFn extends DoFn<String, String> {

        private final Counter businessErrors = Metrics.counter(SafeProcessFn.class, "businessErrors");
        private final Counter technicalErrors = Metrics.counter(SafeProcessFn.class, "technicalErrors");
        private final Counter successCount = Metrics.counter(SafeProcessFn.class, "successCount");

        private static final int MAX_RETRIES = 3;
        private final Random random = new Random();

        @ProcessElement
        public void processElement(@Element String input, MultiOutputReceiver out) {
            int attempt = 0;
            boolean success = false;

            while (attempt < MAX_RETRIES && !success) {
                try {
                    if ("business_error".equals(input)) {
                        businessErrors.inc();
                        throw new IllegalArgumentException("Regra de negócio violada");
                    } else if ("technical_error".equals(input)) {
                        simulateExternalCall(input);
                    } else if ("unexpected_exception".equals(input)) {
                        throw new NullPointerException("Erro inesperado");
                    } else {
                        successCount.inc();
                        out.get(SUCCESS_TAG).output("processed: " + input);
                        success = true;
                    }
                } catch (IllegalArgumentException ex) {
                    out.get(BUSINESS_ERROR_TAG).output(input);
                    return;
                } catch (Exception ex) {
                    attempt++;
                    LOG.warn("Tentativa {} falhou para '{}': {}", attempt, input, ex.getMessage());
                    if (attempt == MAX_RETRIES) {
                        out.get(TECHNICAL_ERROR_TAG).output(input);
                    }
                }
            }
        }

        private void simulateExternalCall(String input) throws Exception {
            if (random.nextInt(3) != 0) {
                throw new RuntimeException("Falha simulada para input: " + input);
            }
        }
    }
}

Running Locally

mvn clean compile exec:java -Dexec.mainClass=com.example.beam.ExceptionHandlingPipeline

Output files will be generated in:

output/success.txt
dlq/business_error.jsonl
dlq/technical_error.jsonl

Conclusion

This simple example demonstrates how to handle different types of errors, protect your pipeline, and maintain full visibility over problematic records. It’s essential for anyone building reliable solutions with Apache Beam.

A resilient architecture is not one that never fails — it's one that handles failure responsibly.

The full code and instructions are available on GitHub:
👉 leandrofmarcos/apache-beam-dlq-example

Feel free to clone, test locally, and adapt it to your own data ingestion pipeline.