Google I/O 2025 has once again demonstrated this intense drive, unveiling breathtaking advancements that amplify the industry's collective push towards a more intelligent, integrated, and intuitive digital experience.

Indeed, as Microsoft CEO Satya Nadella famously said he wanted to "make Google dance," Google I/O 2025 proved that a company celebrating its 26th year can still bust a move or two on the dance floor. Hot on the heels of Microsoft Build 2025, where the Redmond giant championed the "age of AI agents" and the "open agentic web," Google's latest showcase cemented the pervasive future of AI. This isn't just about incremental updates; it's about a fundamental shift in how we interact with our digital world, with AI becoming the core of everything we do. The competition is fierce, but the shared vision for an AI-first era is clear, paving the way for innovations that will transform our daily lives.

Google I/O 2025's Key Highlights and Parallels with Microsoft's Vision

Google's keynote was a masterclass in AI integration, demonstrating how Gemini is evolving into a truly universal AI assistant. Here are some of the key highlights that parallel Microsoft's vision:

Ambient AI and Real-time Interaction

Gemini Live (Project Astra): Google's real-time, camera and screen-sharing AI interaction is a stride towards ambient computing. It allows Gemini to perceive and respond to your surroundings, providing information and assistance on the fly. This mirrors Microsoft's continuous efforts to integrate Copilot deeply within Windows and Microsoft 365, aiming for AI to be a seamless part of your workflow and environment. Real-time translation capabilities are also coming to Google Meet, breaking down language barriers.

Autonomous Agents and Task Automation

Project Mariner and Agent Mode: Google introduced an agent capable of web interaction, multitasking (up to 10 simultaneous tasks!), and learning from demonstrations ("teach and repeat"). The experimental Agent Mode in the Gemini App automates tasks like finding apartments and scheduling tours. This directly aligns with Microsoft's heavy emphasis on "agentic AI" at Build 2025, where new tools to build advanced agentic applications were unveiled.

Reimagined Search and Information Access

AI in Search: A Reimagined Experience: Google's "All-new AI Mode" offers advanced reasoning for complex queries, personalized suggestions, and "Deep Search" that creates expert-level reports. Rolling out widely, this AI mode will provide GPT / Perplexity-like answers directly in Google Search, marking a significant shift in how we find information and potentially signaling "an end of an era for the web."

Foundational Infrastructure and Developer Tools

Foundation and Infrastructure: Google's 7th Generation TPU Ironwood delivers 10x performance, emphasizing the critical need for powerful underlying hardware for AI. This resonates with Microsoft's continuous investments in Azure infrastructure and the introduction of Windows AI Foundry, a unified platform for AI development.

AI for Creativity and Content Generation

Creative Tools and Models: Google unveiled Imagen 4 for enhanced image generation—noted as the #2 best image generation model and the best for speed, particularly excelling in typography. They also showcased Veo 3 for state-of-the-art photorealistic video generation (now with integrated audio), and Lyria 2 for high-fidelity music creation, alongside SynthID Detector for watermarking. This vibrant ecosystem for AI-powered creativity aligns with Microsoft's broad approach to empowering creators and developers with tools and model offerings. The filmmaking tool, Flow, further enhances video creation by allowing for consistent characters and sound effects.

New Frontiers in Human-Computer Interaction

Android XR: The integration of Gemini into XR devices and partnerships with Samsung and Qualcomm to develop Android XR, including concepts like "Android XR Glasses" for hands-free AI interaction, speaks volumes about the future of human-computer interaction. This parallels Microsoft's long-standing commitment to mixed reality and exploration of new hardware paradigms.

Virtual try-on for shopping, allowing users to virtually try on clothes with just a full-body picture and offering better quality than ever before, also promises to revolutionize retail.

What Sets Google Apart: Unique Innovations and Approaches

While many themes overlap, Google I/O 2025 showcased several areas where Google's approach offers distinct innovations or pushes boundaries in unique ways:

Multimodal, Real-time World Interaction (Project Astra's Depth)

While Microsoft is integrating AI, Google's Project Astra, particularly the "live" capabilities that allow Gemini to process and respond to real-time video feeds from your environment, showcases a deeper dive into ambient, context-aware AI interaction that feels particularly advanced in its immediacy and responsiveness to the physical world. This goes beyond simple image recognition to real-time conversational understanding of dynamic visual and auditory input.

Cutting-Edge Model Performance (Deep Reasoning & Specialized Models)

Google's best LLM now features a deeper reasoning mode, allowing it to search multiple hypotheses before making decisions. This model is state-of-the-art on multimodal benchmarks (MMMU), code generation (LiveCodeBench), and achieved 2x the performance of the next best on the USAMO 2025 (math) challenge, demonstrating unparalleled intellectual capabilities. Additionally, the mention of "Gemini Diffusion" as a groundbreaking model that is 10-15x faster than autoregressive models for generating code by utilizing diffusion, a technique previously primarily used for images, marks a significant leap in the speed and efficiency of AI-powered software development.

AI for Software Engineering & Design Transformation

Stitch (UI/UX Design)

Google acquired Stitch, a startup that enables iterative UI design directly from prompts, with the ability to download designs into Figma. This signifies Google's bold move into AI-powered design automation.

Jules (AI Software Engineer)

Jules is an innovative app that allows users to make changes to their GitHub repositories using simple English prompts, without even needing to clone the repo to their local machine – all through a simple UI. This represents a significant step towards a more accessible and intuitive AI software engineering experience.

Integrated Video & Audio Generation (Veo 3) and Comprehensive AI Safety

Google's Veo 3 stands out by natively generating high-quality video with integrated sound effects, background noises, and even dialogue. This integrated audio-visual capability, coupled with the SynthID Detector for invisible watermarks across various media (image, audio, text, video), represents a critical and forward-thinking innovation for AI safety and provenance, arguably more comprehensive in its stated application across media types.

"Thinking Budgets" for Model Control

The introduction of "Thinking Budgets" for Gemini 2.5 Pro, offering developers control over cost and latency versus quality, is a novel approach to managing complex AI model deployments. This granular control over the model's "thinking" process could be a significant differentiator for developers optimizing AI applications, potentially leading to more efficient and sustainable AI solutions.

Android XR and Lightweight Glasses for Daily Use

While both companies are investing in XR, Google's specific focus on lightweight Android XR glasses with in-lens displays, cameras, and microphones, in partnership with fashion brands like Gentle Monster and Warby Parker, suggests a strategic pathway towards more consumer-friendly and ubiquitous AI-powered wearables that integrate seamlessly into daily life, aiming for widespread adoption beyond industrial or specialized use cases.

The Agentic Future is Here

With over 400 million monthly active users for Gemini and processing 480 trillion tokens a month, Google is demonstrating immense scale and leadership in the AI space. Both Google I/O 2025 and Microsoft Build 2025 have made it abundantly clear: AI is no longer just a feature; it's the core of how we will interact with technology. From intelligent agents automating complex tasks to AI seamlessly integrated into our devices and surroundings, the future is about more intuitive, proactive, and personalized digital experiences.

The parallels between these two tech giants' announcements are striking, indicating a shared vision for an AI-first world. As these advancements roll out, we can expect a truly exciting era of innovation that will fundamentally change how we work, create, and connect. The race to build the ultimate AI companion is well underway, and we, the users, are the ultimate beneficiaries.

Microsoft is betting big on AI that acts, that orchestrates, that becomes an integral part of our digital workflows.

The headline grabber? The pervasive focus on AI agents. Microsoft's own Work Trend Index reveals a significant appetite among business leaders for these digital collaborators, and Build delivered the tools to make this vision a reality. We're talking about AI that doesn't just respond to prompts but proactively tackles tasks, learns from context, and even collaborates with other agents to achieve complex objectives. Imagine workflows that self-optimize, projects that manage themselves, and development cycles that anticipate needs – this is the direction Microsoft is heading.

But the agentic future needs a robust foundation, and that's where Azure AI Foundry steps into the spotlight. Think of it as the bedrock for this new era of AI. It's not just a marketplace; it's an integrated environment for crafting, tailoring, and deploying sophisticated AI applications and, crucially, these autonomous agents.

Azure AI Foundry - A Unified Platform for AI Development and Agent Management

Microsoft unveiled Azure AI Foundry, a comprehensive platform designed for developers to build, customize, and manage the next generation of AI applications and intelligent agents. This unified environment aims to streamline the AI development lifecycle, offering a "production line for intelligence" supporting a variety of models.

Azure AI Foundry Models - A Diverse Ecosystem of Cutting-Edge AI

The platform now features Azure AI Foundry Models, significantly expanding the range of AI models available on Azure. This comprehensive catalog includes leading models from various providers, offering developers a wide array of capabilities to choose from. Notably, this includes the integration of Grok 3 and Grok 3 Mini models from xAI, Elon Musk's AI company. Beyond xAI, Azure AI Foundry provides access to models from OpenAI (including the latest GPT-4o), Meta (Llama family), Mistral AI, Cohere, and Stability AI, among others. This diverse selection ensures that developers can leverage the best-suited intelligence for their specific applications, all hosted and billed directly through Microsoft Azure. Azure's new model router automatically chooses the best OpenAI model for a given task, further optimizing performance. The platform boasts access to over 1,900 partner and Microsoft-hosted models.

Streamlining Agent Development and Management in Azure AI Foundry

Microsoft is providing developers with a suite of tools to simplify the creation and management of AI agents within Azure AI Foundry. The Foundry Agent Service allows building declarative agents with just a few lines of code, streamlining the development process. Agents built in Foundry and Copilot Studio automatically appear in an agent directory in Entra. To help developers navigate the vast model ecosystem, Microsoft introduced the Model Leaderboard for performance comparison and the Model Router for intelligent, real-time model selection based on specific needs. Ensuring the reliability and efficiency of AI agents, Microsoft is also adding Azure AI Foundry Observability features. These built-in monitoring tools will track agent performance, quality, cost, and safety.

Enhancing Microsoft 365 Copilot with Customization and Collaboration

Microsoft is significantly boosting the capabilities of Microsoft 365 Copilot. The introduction of Microsoft 365 Copilot Tuning will allow organizations to train models and build custom AI agents using their own data, workflows, and processes in a low-code environment, tailoring the AI to their specific needs. Furthermore, Microsoft is unveiling multi-agent orchestration within Copilot, enabling the creation of systems where multiple AI agents can collaborate to tackle more complex tasks and achieve broader organizational goals, transforming how teams work together.

GitHub Copilot: From Pair Programmer to Autonomous Agent – Embracing "Vibe Coding"

For developers, GitHub Copilot is rapidly evolving from a helpful pair programmer to a more autonomous agent within the development workflow. Microsoft is deeply integrating Copilot extensions into the core open-source repository, and the introduction of Agent mode in Visual Studio Code promises a more context-aware coding assistant. This enhanced Copilot can now leverage information from multiple files and data sources to provide more intelligent suggestions and even proactively address development tasks, fostering what some are calling "vibe coding" – a more fluid and intuitive development experience where the AI seamlessly anticipates and assists your coding flow.

Perhaps one of the most compelling moments of Microsoft Build was Satya Nadella's live demonstration of GitHub Copilot in action. In a powerful display of its evolving capabilities, Copilot was assigned a real-world pull request (PR) task directly within GitHub. The AI agent didn't just suggest code; it analyzed the issue, proposed the necessary code changes, implemented them, and even generated the pull request itself – all in real-time. This wasn't a scripted scenario; it was a tangible glimpse into a future where AI seamlessly integrates into the development workflow, automating even intricate tasks like code contributions and PR management. GitHub Copilot is becoming central to how we code, moving beyond a simple assistant to a true peer programmer capable of handling significant development responsibilities.

Copilot Edits for Natural Language Code Modifications

Streamlining the code modification process, Copilot Edits will allow developers to make inline code changes across multiple files using natural language prompts, all while maintaining developer control over the applied changes.

Enhanced Visual Studio and VS Code

Microsoft is also improving its core development tools. Visual Studio is getting better with .NET 10 support, live preview at design time, improved Git tooling, and a new debugger for cross-platform apps. Stable releases will now occur monthly. VS Code received improved multi-window support and easier staging directly from the editor in its 100th release. Furthermore, Microsoft reiterated its commitment to the open-source community by announcing plans to open-source even more components of Visual Studio Code, building on its already significant open foundation. This move aims to foster greater collaboration and extensibility within the developer ecosystem.

NLWeb: The HTML of the Agentic Web

Microsoft CTO Kevin Scott drew a compelling parallel, comparing the Model Context Protocol (MCP) to HTTP and introducing NLWeb as a potential HTML for the emerging "agentic web." NLWeb is an open-source project designed to simplify the integration of AI interfaces into websites. It allows developers to add a conversational interface, powered by their chosen AI model and data, with minimal code. Every NLWeb instance also functions as an MCP server, enabling websites to make their content readily accessible to AI agents within the MCP ecosystem. The Model Context Protocol (MCP) is an open standard designed to standardize the way AI models integrate and share data with external tools, systems, and data sources. It provides a universal interface for AI assistants to read files, execute functions, and handle contextual prompts, facilitating seamless communication between AI and various applications.

Microsoft Discovery - AI for Accelerated R&D

In the realm of research, Microsoft introduced Microsoft Discovery, an extensible platform leveraging agentic AI and a graph-based knowledge engine to accelerate the entire research and development process. In a demonstration, Discovery was used to identify and synthesize PASF-free immersion coolants.

Data Integration and Storage

Cosmos DB is being integrated directly into Foundry for storing and retrieving conversational history. Cosmos DB is also being brought to Fabric, allowing AI apps to access structured and semi-structured data. For use cases needing low latency and explicit control, Azure Local is offered. Azure Local extends Azure to customer-owned infrastructure, enabling local execution of modern and traditional applications across distributed locations. This solution offers a unified management experience on a single control plane.

Of course, no discussion about cutting-edge technology is complete without acknowledging the ethical considerations. Microsoft's acknowledgment of providing AI services to the Israeli military and the subsequent internal reviews highlight the complex tightrope walk that tech giants navigate. The commitment to responsible AI development and deployment remains a critical aspect of this journey.

The recent layoffs within Microsoft, while undoubtedly impacting individuals, are widely seen as a strategic recalibration, a reallocation of resources towards the immense potential of AI. This bold restructuring underscores the company's conviction in the transformative power of artificial intelligence.

Introduction: The Problem of "Ghost Events"

Imagine this: Your e-commerce app processes an order, saves it to the database, and tries to publish an OrderCreated event to notify other services. But what if the database commit succeeds, and the event publish fails? Suddenly, inventory isn’t updated, payment isn’t processed, and your users are left hanging. 

This is the dual-write problem: ensuring atomicity between database updates and event publishing. Enter the Transactional Outbox Pattern—a battle-tested solution to keep your system consistent. Let’s break it down!

What’s the Transactional Outbox Pattern?

The idea is simple but powerful:

1. Bundle your database update and event into a single transaction.
2. Store the event in an "outbox" table in the same database.
3. Relay events to the message broker asynchronously (e.g., via a background worker).

No more half-baked states! If the transaction commits, the event is guaranteed to eventually publish.

1. Define the Outbox Table Entity

import jakarta.persistence.*;
import java.time.LocalDateTime;
import java.util.UUID;

@Entity
@Table(name = "outbox_messages")
public class OutboxMessage {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private UUID id;

    @Column(name = "event_type", nullable = false)
    private String eventType;

    @Column(name = "payload", nullable = false, columnDefinition = "TEXT")
    private String payload;

    @Column(name = "created_at", nullable = false)
    private LocalDateTime createdAt;

    @Column(name = "processed", nullable = false)
    private boolean processed;

    // Getters and Setters
}

2. Save Data and Event in One Transaction

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@Service
public class OrderService {

    ...

    @Transactional
    public void createOrder(Order order) throws JsonProcessingException {
        // Save the order
        orderRepository.save(order);

        // Create the event payload
        OrderCreatedEvent event = new OrderCreatedEvent(order.getId());
        String payload = objectMapper.writeValueAsString(event);

        // Save the event to the outbox
        OutboxMessage outboxMessage = new OutboxMessage();
        outboxMessage.setId(UUID.randomUUID());
        outboxMessage.setEventType("OrderCreated");
        outboxMessage.setPayload(payload);
        outboxMessage.setCreatedAt(LocalDateTime.now());
        outboxMessage.setProcessed(false);

        outboxMessageRepository.save(outboxMessage);
    }
}

3. Background Worker to Publish Events

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Component
public class OutboxPublisher {

    private final OutboxMessageRepository outboxMessageRepository;
    private final MessageBroker broker;

    public OutboxPublisher(OutboxMessageRepository outboxMessageRepository, MessageBroker broker) {
        this.outboxMessageRepository = outboxMessageRepository;
        this.broker = broker;
    }

    @Scheduled(fixedDelay = 1000) // Poll every second
    @Transactional
    public void publishEvents() {
        List<OutboxMessage> messages = outboxMessageRepository.findByProcessedFalse();

        for (OutboxMessage message : messages) {
            try {
                broker.publish(message.getEventType(), message.getPayload());
                message.setProcessed(true);
                outboxMessageRepository.save(message); // Mark as processed
            } catch (Exception ex) {
                // Log and retry later
                ex.printStackTrace();
            }
        }
    }
}

4. Repository Interfaces

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.UUID;

public interface OutboxMessageRepository extends JpaRepository<OutboxMessage, UUID> {
    List<OutboxMessage> findByProcessedFalse();
}

public interface OrderRepository extends JpaRepository<Order, UUID> {
    // Custom query methods if needed
}

5. Event and Order Classes

public class OrderCreatedEvent {
    private UUID orderId;

    public OrderCreatedEvent(UUID orderId) {
        this.orderId = orderId;
    }

    // Getters and Setters
    public UUID getOrderId() { return orderId; }
    public void setOrderId(UUID orderId) { this.orderId = orderId; }
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private UUID id;

    // Other fields
    private String productName;
    private int quantity;

    // Getters and Setters
}

6. Message Broker Interface

public interface MessageBroker {
    void publish(String eventType, String payload);
}

Key take aways in implementation

1. Transactions: Use @Transactional to ensure atomicity between database operations.
2. Polling: The @Scheduled annotation simplifies background processing. For production, consider Change Data Capture (CDC) tools like Debezium.
3. Idempotency: Ensure your MessageBroker implementation handles duplicate events gracefully.

Best Practices

1. Idempotency is King: Design your event handlers to handle duplicates gracefully.
2. Order Matters: Use CreatedAt timestamps or sequence IDs to ensure events are processed in order.
3. Monitor the Outbox: Alert if unprocessed events pile up—it could indicate a broker outage. Your broker if is a queue then add alerting on Dead-Letter Queue.
4. Use JSON Schema: Validate event payloads to avoid malformed data.

Debezium Alternatives

• AWS DMS (Database Migration Service): A managed service for real-time CDC and database replication. Best for AWS users who want a no-maintenance solution.
• Maxwell’s Daemon: A lightweight CDC tool for MySQL. Great for simple, MySQL-only use cases.
• Kafka Connect JDBC Source Connector: Polls databases for changes and streams them to Kafka. Ideal for non-real-time, polling-based systems.
• Oracle GoldenGate: Enterprise-grade CDC tool for Oracle databases. Perfect for Oracle users needing high-performance replication.
• Bottled Water (for PostgreSQL): A PostgreSQL-specific CDC tool that streams changes to Kafka. Best for PostgreSQL users looking for a lightweight solution.

Conclusion: Consistency Wins!

The Transactional Outbox Pattern is your ally in the quest for reliable distributed systems. By combining atomic database writes with asynchronous event propagation, you eliminate ghost events and sleep better at night. 😴

Dependency Injection is very useful for most projects and allows us to create our dependencies easily and makes the development process seamless.

Join us, where we will be creating a Dependency Injection framework from scratch with the least amount of libraries possible. We would be exploring Java's Reflection and creating our dependency resolution strategy to resolve bean (object) resolution.

Hope this exploration and building framework will help you understand the internals of reflection and how dependency injection works in Spring Framework.

This small container can be easily used to create Dependency Injection in. your own projects, embeddable in any project, and if you are writing a lean library too, this journey would be worthwhile.

Feign is a declarative client which makes it easy to create an HTTP client by defining only Java Interfaces and endpoints as interface methods. Simple and straightforward easy-to-use client can be used as OpenFeign when you want to use it with Spring Boot.

But, there would be cases in your project where you might want to reuse the client in multiple services or modules such that you could maintain the REST service endpoints by versioning them via the release version of your library.

Feign provides an easy to either create a config-based initiation supporting auto-enabled configuration provided by Spring via @EnableFeignClients annotation. When using OpenFeign with Spring configuration can be done via the prefix:

feign.client.config.<client-name>.*

An example config application.yaml would look something like

feign:
  client:
    config:
      feignName:
        connectTimeout: 5000
        readTimeout: 5000
        loggerLevel: full
        errorDecoder: com.example.SimpleErrorDecoder
        retryer: com.example.SimpleRetryer
        requestInterceptors:
          - com.example.FooRequestInterceptor
          - com.example.BarRequestInterceptor
        decode404: false
        encoder: com.example.SimpleEncoder
        decoder: com.example.SimpleDecoder
        contract: com.example.SimpleContract

But, if you want to customize, Feign Builder can be used to construct Feign Clients beans as well. In order to create multiple custom beans in Spring, we could use one of  BeanDefinitionRegistryPostProcessor or ImportBeanDefinitionRegistrar and implement the required methods and annotate your class as @Configuration

Both of these configurations would let you use class BeanDefinitionRegistryPostProcessor which lets you register a bean as

registry.registerBeanDefinition("", createBeanDefination(feignClient));


private BeanDefinition createBeanDefination(Object client) {
    var definition = new RootBeanDefinition();
    definition.setBeanClass(client.getClass());
    definition.setInstanceSupplier(() -> client);

    return definition;
}

When using BeanDefinitionRegistryPostProcessor your configuration class would look something like this:

@Configuration
public class AppConfig implements BeanDefinitionRegistryPostProcessor {
 
    private BeanDefinition createBeanDefination(Object client) {
        var definition = new RootBeanDefinition();
        definition.setBeanClass(client.getClass());
        definition.setInstanceSupplier(() -> client);
 
        return definition;
    }
 
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // init builder
        var feignClient = Feign.builder().build();
 
        registry.registerBeanDefinition("", createBeanDefination(feignClient));
    }
 
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
 
    }
}

The ImportBeanDefinitionRegistrar would let you get metadata information from your Custom Enable Annotation in Spring. So, for example, if you want to initiate your clients via custom annotation and want to get annotation metadata we can do so like.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EnableCustomFeignClients {
    Class[] clients() default {};
}

@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
    Map attrs = annotationMetadata.getAnnotationAttributes(EnableCustomFeignClients.class.getName(),
            true);
    Class[] clients = attrs == null ? null : (Class[])attrs.get("clients");

    // init specific client classes

    // init builder
}

If you are writing a library, it's much better to let the configuration command the builder. The configuration mentioned in your application.yml with your custom prefix should govern which clients to initiate. This allows users of the library to configure only those clients which are required to be and only those would get initiated with your custom initiation configuration.

You can write your custom configuration with your prefix based on your needs.

mycompany.client.name.configX=1000
...

Problem: Cannot inject your Custom Configuration properties.

Since we are doing pre-initiation processing, the @ConfigurationProperties does not work here for us. The way to do this is to use Binder which can bind environment properties from application.yml configuration with prefixes to your custom DTOs.

Also in order to get Environment Object, we can make our @Configuration class EnvoirnmentAware.

@Configuration
public class AppConfig implements BeanDefinitionRegistryPostProcessor, EnvironmentAware {

    private Environment environment;
    private Map config;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // init binder
        this.config = Binder.get(this.environment)
                .bind("myconfig.web.client", Bindable.mapOf(String.class, MyConfig.class))
                .orElseThrow(IllegalStateException::new);
    
        // init builders
        ...
    }

}

Now, let's talk about registering your @FeignClient annotated classes in your custom feign client registration configuration class.

To create the client, you can configure a few basic configurations listed here.

var feignClient = Feign.builder()
                .contract()
                .encoder()
                .decoder()
                .errorDecoder()
                .retryer()
                .target(, "url");

registry.registerBeanDefinition("clientName", createBeanDefination(feignClient));

• Contract
• Encoder
• Decoder
• ErrorDecoder
• Retryer
• Target

Contract

When using Spring, we can use class SpringMvcContract class which allows Spring to use its own MVC web annotations like @RequestMapping, @GetMapping, @PostMapping etc. on Feign client methods.

.contract(new SpringMvcContract())

However, you might end up in a situation where you want your client's endpoints uri too needs to be configurable. For this Spring already have placeholder resolution in place but this would not work directly out of the box when creating a custom client.

@FeignClient(name = "pet")
interface PetClient {

    @GetMapping(value = "${pet.getpets.url}")
    JsonNode getPets();
}

In order to resolve the placeholder like ${pet.getpets.url} we would have to set ResourceLoader it to our SpringMvcContract. We can easily do that by implementing ResourceLoaderAware class like this and then setting the ResourceLoader in our SpringMvcContract.  

@Configuration
public class AppConfig implements BeanDefinitionRegistryPostProcessor, ResourceLoaderAware {

    private ResourceLoader resourceLoader;

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    @Bean
    Contract springMvcContract() {
        var contract = new SpringMvcContract();
        contract.setResourceLoader(this.resourceLoader);

        return contract;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // init builder
        var feignClient = Feign.builder()
                .contract(springMvcContract())
                ...
    }
}

Encoder/Decoder

Based on your client config you can pick and set the required Encoder and Decoder for the client. For eg. if your content is application/json type, we can register the encoder and decoder as:

@Bean
Encoder feignEncoder() {
    var jsonMessageConverters = new MappingJackson2HttpMessageConverter(new ObjectMapper());
    return new SpringEncoder(() -> new HttpMessageConverters(jsonMessageConverters));
}

@Bean
Decoder feignDecoder() {
    var jsonMessageConverters = new MappingJackson2HttpMessageConverter(new ObjectMapper());
    return new ResponseEntityDecoder(new SpringDecoder(() -> new HttpMessageConverters(jsonMessageConverters)));
}

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    // init builder
    var feignClient = Feign.builder()
            .contract(springMvcContract())
            .encoder(feignEncoder())
            .decoder(feignDecoder())
            ...
}

ErrorDecoder

ErrorDecoder is where we can write about custom exception throwing for a handler method and then can handle it later in the code. However, when writing a library we might want the most generic way to handle exceptions. By default, Feign would throw FeignException whenever there is no 2XX response code.

Along with throwing exceptions, Feign also allows retry of exception marking via ErrorDecoder . If a method throws RetryException then instead of throwing it, first it invokes the Retryer. A default implementation of the error decoder is also available which can be directly hooked into your custom client builder.

Retryer with ErrorDecoder

Feign has given an interface to handle in case you would want to retry in specific cases. A simple custom retryer would look like this:

static class Retryer implements feign.Retryer {

    @Override
    public void continueOrPropagate(RetryableException e) {
        
    }

    @Override
    public feign.Retryer clone() {
        return null;
    }
}

Every single method invocation is wrapped around InvocationHandler where the client's Retry info is used to check they it is registered and do we want to retry the handler again. The method continueOrProgagate lets us hook logic if we want to continue to retry.

However, you might want to retry only in certain cases or probably on certain methods only in case of specific configured error codes. I did not find any direct way to configure retry per method inside the client feign client.

Problem: No feature to enable Retry on a single client method based on configuration by default.

In order to resolve that, I used ErrorDecoder with Custom Retryer as follows:

First, implement a custom exception that extends feign provided exception class RetryException. Here, we would want to capture information about the method by which the exception has occurred.

But before this, let us customize our configuration to allow per-method retry configuration. The property retryMethod would have this configuration per client and then per method.

static class MyConfig {
    private String url;
    private Logger.Level loggerLevel;
    private Integer connectTimeout;
    private Integer readTimeout;
    private RetryConfig retry; // client level retryconfig
    private Map<String, RetryConfig> retryMethod; // methodname-key : retryconfig
}

static class RetryConfig {
    private Integer maxAttempts;
    private Long period;
    private Long maxPeriod;
    private List<Integer> retryCodes = List.of(500, 502, ...);
}

An example of the config would look like

myconfig.web.client.petClient.getPets.maxAttempts=4

Extending the RetryException class:

static class MyRetryException extends RetryableException {

    private final RetryConfig retryConfig;
    public MyRetryException(RetryConfig retryConfig, int status, Request.HttpMethod httpMethod, Request request) {
        super(status, "", httpMethod, null, request);
        this.retryConfig = retryConfig;
    }
}

Here, we have captured information about the retry config, which we expect from our Custom Error Decoder ErrorDecoder,  which is declared as:

static class MyErrorDecoder implements ErrorDecoder {

    private final ErrorDecoder decoder = new ErrorDecoder.Default();
    private final RetryConfig clientRetryConfig;
    private final Map methodRetryConfig;

    public MyErrorDecoder(RetryConfig clientRetryConfig, Map methodRetryConfig) {
        this.clientRetryConfig = clientRetryConfig;
        this.methodRetryConfig = methodRetryConfig;
    }

    @Override
    public Exception decode(String s, Response response) {
        // get method name
        var methodName = response.request().requestTemplate().methodMetadata().method().getName();

        RetryConfig retryConfig = null;
        // if methodName config found in any method or client level config
        // retryConfig = this.methodRetryConfig.get(methodName);

        // check if retry status code
        var status = response.status();
        if (retryConfig != null && retryConfig.retryCodes.contains(status)) {
            var httpMethod = response.request().httpMethod();
            return new MyRetryException(retryConfig, status, httpMethod, response.request());
        }

        return decoder.decode(s, response);
    }
}

Now, based on our global or method-level retry config, we can throw our custom RetryException called MyRetryException.

Customizing the Retryer would be a little hacky. We would check if thrown an exception if that is instanceof our custom MyRetryException, if yes we would initiate the internally created instance of the Default Retryer provided by Feign. The Default implementation of Retryer by default uses backoff as exponential which is the preferred way in microservices.

static class MyRetryer implements feign.Retryer {

    private Retryer retryer;
    private Retryer initAndGet(RetryConfig retryConfig) {
        if (retryer == null) {
            retryer = new feign.Retryer.Default(
                    retryConfig.period,
                    retryConfig.maxPeriod,
                    retryConfig.maxAttempts
            );
        }

        return retryer;
    }

    @Override
    public void continueOrPropagate(RetryableException e) {
        if (e instanceof MyRetryException) {
            MyRetryException retryException = (MyRetryException) e;
            initAndGet(retryException.retryConfig).continueOrPropagate(e);
        }

        throw e;
    }

    @Override
    public feign.Retryer clone() {
        return new MyRetryer();
    }
}

Now, that all components of your custom feign builder are ready, we can start registering the client. We can loop through the configured clients and can initiate the builder and then we can register all candidate client beans.

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    // init binder
    this.config = Binder.get(this.environment)
            .bind("myconfig.web.client", Bindable.mapOf(String.class, MyConfig.class))
            .orElseThrow(IllegalStateException::new);

    // get classes annotated with @FeignClient
    var annotatedTypeScanner = new AnnotatedTypeScanner(FeignClient.class);
    var candidateClients = annotatedTypeScanner.findTypes("...base.package.lib.client");

    candidateClients.forEach(candidateClient -> {
        FeignClient annotation = candidateClient.getAnnotation(FeignClient.class);
        if (config.containsKey(annotation.name())) { // check if client name matches config name
            var clientConfig = config.get(annotation.name());
            var feignClient = Feign.builder()
                    .contract(springMvcContract())
                    .encoder(feignEncoder())
                    .decoder(feignDecoder())
                    .options(new Request.Options(clientConfig.connectTimeout, clientConfig.readTimeout))
                    .errorDecoder(new MyErrorDecoder(clientConfig.retry, clientConfig.retryMethod))
                    .retryer(new MyRetryer())
                    .target(candidateClient, clientConfig.url);

            var clientName = String.format("%sClient");
            registry.registerBeanDefinition(clientName, createBeanDefination(feignClient));
        }
    });
}

That is it. Now once this setup is wrapped as a lib, we can just use @EnableCustomFeignClients along with relevant connection configuration in application.yml to use it in any Spring Boot application.

In this post, we will configure AWS CloudFront distribution to provide restricted access to S3 bucket private contents so that objects can only be accessed through CloudFront Signed URL.

A signed URL includes additional information such as expiration date, that provide user applications to have better control over access to the content.

Prerequisite

1. AWS account with console access.
2. Any Java IDE to generate signed URL code
3. OpenSSL utility to generate public/Private Key

Now let’s start with the steps for the workflow.

Create S3 Bucket

Login to AWS console search for S3 service or go to https://s3.console.aws.amazon.com

Click on S3 that leads to S3 console and follow the Create bucket button that lands to create bucket form.

Choose a globally unique and valid name for the bucket, choose AWS region for which logged in user have persimmon to create bucket. Make sure the “Block all public access” checkbox is checked. Left rest of the settings to default and click on create bucket.

Create a key pair

In following steps, OpenSSL is used to create key pair to make a trusted key pair group for CloudFront.

There are other tools as well to create public/private key pairs.

• Use the following command to generate RSA key pair and save it in a file named private_key.pem.

openssl genrsa -out private_key.pem 2048

• The following command will extract the public key from the generated file and save it in public_key.pem.

openssl rsa -pubout -in private_key.pem -out public_key.pem

• Later this post will use java to generate signed URLs so the private key pair file cannot be used directly, instead PEM to DER conversion is required. Use the following command to do so.

openssl pkcs8 -topk8 -nocrypt -in private_key.pem -inform PEM -out private_key.der -outform DER

Keep aside the files created as these will be required later while creating CloudFront Distribution to be used as signers to create signed URLs.

Creating the signers in CloudFront

Use the following steps to create a signer in cloud front,

• Open CloudFront Console and from the left hamburger menu, navigate to public keys under key management section.

• Go to Public keys and create one by providing appropriate name and paste the contents of public_key.pem file in Key section.
• In the same key management section, go to key groups and create a key group with the public key created in previous step.

Now let’s move on and create cloud front distribution.

Create CloudFront Distribution

Search for CloudFront in AWS console.

Open CloudFront console and click on “Create a CloudFront distribution” that opens the create CloudFront distribution form.

From the origin dropdown, select the bucket created in previous step as Origin domain.

For Origin access, choose from options given,

1. Origin access control settings, which is recommended where you need to update the bucket policy, to allow access to IAM service principal, provided when distribution is created, or

2. Legacy access identities where an option to update the bucket policy is provided. This will update the S3 bucket policy so that the bucket can be accessible using the cloud front distribution.

Choose the recommended one and create control setting and use the same.

Choose Allowed HTTP methodsas required.

In Restrict viewer access, select yes and keep Trusted authorization type as Trusted key groups. In Add key groups section, select the key group from the drop down created in previously.

This will bind the key pair created in previous section so that one must need to create CloudFront Signed URL to access S3 Bucket content associated with distribution.

In cache and Origin Request, select CachingDisabled so that any update in s3 object will immediately reflected while fetching it.

Now create CloudFront distribution keeping other options as default.

On success distribution detail page will open where on top of the page, copy the policy statement.

Update access policy in S3 bucket

Go to S3 console (https://s3.console.aws.amazon.com) and select the same bucket used in cloud front distribution as origin.

Move to bucket policy section under Permission tab, edit the bucket policy and paste the contents of bucket policy copied.

For this policy, the allowed action is restricted to read the objects, that can be modified as per requirement. Let’s update the action and add permission to write objects as well. To do so, replace the action line with following.

"Action": ["s3:GetObject","s3:PutObject"],

The resulting statement will look like mentioned below.

Save the changes.

With this configuration part is completed and now let’s move on to create cloud front signed URL.

Generating CloudFront Signed URL

Steps and code to generate cloud front signed URL is explained below.

Create spring boot gradle project and add the below dependencies to it.

implementation 'com.amazonaws:aws-java-sdk-cloudfront:1.12.283'

Here is the code for generating cloud front signed URL.

import java.io.File;
import java.io.IOException;
import java.security.spec.InvalidKeySpecException;
import java.util.Date;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.amazonaws.services.cloudfront.CloudFrontUrlSigner;
import com.amazonaws.services.cloudfront.util.SignerUtils;

@SpringBootApplication
public class CloudfrontsignedurlApplication implements CommandLineRunner {

	public static void main(String[] args) {
		SpringApplication.run(CloudfrontsignedurlApplication.class, args);
	}

	@Override
	public void run(String... args) throws Exception {
		String cloudFrontKeyPairId = "<public_key_id>"; // public key id created in cloud front key management section.
		String distributionDomain = "<cloud_front_distribution_name>"; // cloud front distribution domain name.
		String key = "cloudfrontsignedurl/objetc1.txt"; // S3 bucket object path

		Date expirationDate = new Date(System.currentTimeMillis() + 7200000); // Token will be valid for 2 hour
		try {
			File cloudFrontPrivateKeyFile = generateCloudFrontPrivateKeyFile();
			String signedUrl = CloudFrontUrlSigner.getSignedURLWithCannedPolicy(SignerUtils.Protocol.https,
					distributionDomain, cloudFrontPrivateKeyFile, key, cloudFrontKeyPairId, expirationDate);
			System.out.println(signedUrl);

		} catch (IOException | InvalidKeySpecException exception) {
			throw new Exception(exception.getMessage());
		}
	}

	private File generateCloudFrontPrivateKeyFile() {
		File file = new File("<private_key_file>"); // Path to public/private key pair file.
		return file;
	}
}

The generated signed URL will look as mentioned below.

https://d26doxj2i1y97q.cloudfront.net/cloudfrontsignedurl/objetc1.txt?Expires=1661499384&Signature=LabCbO27wL1-ErAEwYU9CBGh1pVdmRY2oQ94QfQP9cGi4vQTNgo7xT3ctbr6lAolcH5AZEe-I79s~spEA6VCnRUIstsvDhLoN4spJHrQxlecapxKK7P0J9U6kXL8V2ucDgwrJmFfdFWpipeGkgTVgKJ~s53Unp76YrTJODYnX-ZZc3RuQ4go5oBYhXU2hRHKlVusV3llhlOyfN58FxytzAZkegECRj6LR6m0WzRI-guCPqHCO7Gir~Ls5ewCw-TZpAyMca-LjKAeTGd~KS4etFgr5Tbt3UrGiDXJVoDkCcc-Z1cu9xu34s9ZQHqSD-t7AHdCszv6sitRcFK9PSJQyg__&Key-Pair-Id=K1HEUAHR3KG1E3

This URL can be used to upload and download the object to S3 bucket.

Note** One also need to set the Access Key ID and Secret Access Key for programmatic access.

Complete code for generating the signed URL can be found at Github.

To get best computational efficiency from a multicore processor core, kernels of operating systems uses Kernel-Level threads to provide concurrency. However, to get most out of the threads, OS has User-Level threads which can be used by programming languages to achieve multithreading and control is with users to handle them.

The need of computational efficiency have been increasing and so does the need for concurrency. But before discussing the need of concurrency let's first discuss the difference between concurrency and parallelism.

When we talk about concurrency, we need to talk about handling multiple task together but when we talk about parallelism, it's about executing those multiple tasks together. OS's kernel threads are not up to the developer to handle they are handled directly by operating system on its own and handling of task scheduling on these threads.

Programming languages have allowed developers to use user level threads which can be managed by the program. A thread needs to be spawned and then it can run, wait or suspend which can be explicitly controlled by the developers the way it is programmed. This allows task preemption on threads and tasks to be loaded or unloaded from execution state.

OS's thread preemption is a good to execute and distribute your tasks over the processor, however the preemption is costly between threads. This Context-Switching between the threads adds latency to the execution. However, programming languages have been evolving themselves to overcome this. In general, we see 2 paradigm's in current major programming languages to handle this.

The Async-Await async-await (Eventloop) way to handle better preemption is used in

• Javascript
• Rust
• C++
• C#

Lightweight Threads: used in

• Go
• Java

Specially, when talk about Java's reactive programming library, it tries to emulate eventloop, but they are based on threads only. Let's discuss the different styles of evolving programming language efficiency of preemption in race of Need for Concurrency.‌

Async-Await Scheduling

In in this type of concurrency task handling , the code structured in a way such that the operation can be suspended in the sequence of flow and can be blocked using await statement. So basically the developer would split their code into different functions which can be executed concurrently.The internal framework of the programming language puts these structured functions into an event queue. On this event queue, scheduling is done such that a task get executed one by one. Whenever there is any async operation is encountered, task is again push to this queue.

Generally a good split of code can be decided by the operation which are blocking calls: I/O or Network call or File Operation. All these operations are blocking in nature and system OS calls required to perform them blocks the current thread.

This way the flow of execution of code does not have to wait for the next statement to execute, whenever the blocking operation is complete, asynchronous nature will allow the scheduled task to return back to execution state with context.

So this way the CPU thread would not need to get blocked and it's the programming language which made it possible by preempting the tasks conditionally. The executing thread never goes to weight state in there is no need for preemption by OS.

Lightweight Threads

These threads are the newer thread implementation of executors itself within programming language framework which would use underlying threads to achieve efficient concurrency. Also, in some languages they are also called as Virtual threads.

Here, this lightweight thread construct handles the execution of tasks over the OS level provided threads. This custom implementation of scheduling task follow their own algorithm to pick and distribute tasks on each existing thread.

Golang's Scheduler

Golang has the option of running this parallel runnable tasks into lightweight threads which are called Goroutines and executable runnables are defined as functions with special keyword go and executions are handled by golang's internal scheduler.

Golang would spawn fix a number of threads based on GOMAXPROCS variable or by default current processors number. It maintain a local run queue and global run queue of Goroutines. Any new runnable Goroutines are added to one of the threads local run queue and that's how it gets scheduled for execution.

However, that's not it. Whenever, there is a blocking operation inside a Goroutine, the scheduler will preemt this execution and allows next Goroutine to execute avoiding blocking the underlying execution for thread efficiency.

The suspended Goroutine can be queued to any of the available process object's local run queue. This way of switching where same Goroutine can be executed among multiple threads is also called Cooperative Scheduling.

Another caveat in the golang's scheduler is the Work-Stealing nature of virtual threads. Whenever process is free of any queued Goroutine they can steal queued routines from other local or global queue. Or also from Network Poller in predefined way. This way task balancing is done and none of the threads gets overloaded by Goroutines run queues.

Kotlin's Coroutines

Kotlin routine uses continuation steps, in which each step is a structured execution fragment that can be preempted.  Here, the lightweight routines are basically finite state machine that uses these defined steps. Continuation steps are defined by the developer which in turn are implicitly handled by Kotlin's compiler. So whenever a blocking step is encountered, the continuation step is suspended and the next step can be queued again for execution and the suspended step when completes its blocking operation can be queued back for execution.

Java's Reactive (RxJava)

RxJava has various implementations of Schedulers like parallel, elastic, single, boundedElastic, immediate. These schedulers basically run the async task on the ExecutorService's threadpool which are implemented based to handle different use cases. For instance, parallel would use ExecutorService's fixed thread pool etc. and is recommended for computational tasks. But, if devs did not choose these schedulers wisely, can result in backpressure issue.

The Library provides methods like subscribeOn , publishOn and runOn to use signalling then publish (run) the task separately on different threads and when blocking operation task is complete, we can listen to the result on subscribed thread.

There is also a learning curve in writing the clean code. Error logging in RxJava would have huge stacktrace and is difficult to debug and narrow down the business logic error.

Again, with Java 19's Virtual Thread performance can be made much more efficient since they provide better preemption and concurrency.

Java's Virtual Threads

Originally Java's Green threads are the user-level thread that can be handled by users (devs) to simulate kernel-level multithreading.  Future , CompleteableFuture , Thread Executors threadpools  are already available in Java thread package to perform multithreading operations.  With Java 19,  these classic thread are now designated as platform threats while introducing a new lightweight threads called Virtual Threads.

These lightweight threads would use existing thread pool to perform execution of tasks.  A dedicated ForkJoinPool FIFO model is used as Virtual Thread Scheduler.  which will save the unloaded (unmounted) thread execution stack in heap,  so that the execution can continue from the point of suspension.

In case, if the runnable code of Virtual Thread is blocking and there seem to be no way to reschedule, Virtual Threads would park (hold) the execution state and at this point the underlying thread would also be blocked. The execution stack of the thread would be saved be saved on JVM's heap.

Otherwise, the Virtual Threads would yield whenever a blocking operation is encountered and to enable this many base core Java Classes have been modified.   It's really good to see that attempt been made to keep up the way of coding similar to the way it has been for older classical platform threads.

With great power comes great responsibility. Languages work their best for abstraction but using these new features also require learning about these schedulers well too.

Argo CD is a declarative Git-Ops continuous delivery tool created for Kubernetes.

k8s application manifests should be version controlled in a git repository. Argo CD uses the git repository as a source of truth which represent the desired state of the application.

Argo CD is implemented as a k8s controller which continuously monitor current or live state with the desired state described in the git repository and automate the deployment of desired state in k8s environment.

Prerequisite

Before moving forward, some tools are required to complete the exercise,

• A local Kubernetes cluster, for example Docker Desktop or Minikube
• kubectl
• Git account and git CLI
• Argo CD

The installation instructions for local Kubernetes cluster can be found in respective links.

Installing Argo CD

As mentioned before, Argo CD is implemented as a custom controller, so it needs to be deployed in k8s.

Let's create a separate namespace for Argo CD installation.

kubectl create ns argocd

Coming back to our main section, now lets install ArgoCD in newly created namespace.

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

This took around 3-5 minutes, you can check the status of deployment using kubectl get deployment which will give output as follows:

NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
argocd-dex-server    1/1     1            1           5m28s
argocd-redis         1/1     1            1           5m28s
argocd-repo-server   1/1     1            1           5m28s
argocd-server        1/1     1            1           5m28s

Access Argo CD API Server

By default, the Argo CD API server is not exposed with an external IP. To access the API server, choose one of the following techniques to expose the Argo CD API server:

1. kubectl patch svc argocd-server -n argocd -p '{"spec": {"type": "LoadBalancer"}}'
2. kubectl port-forward svc/argocd-server -n argocd 8081:443

Use localhost:8081 to access the API server in browser.

Login to Argo CD

Default username to login to Argo CD server is admin, to get the password there are several ways.

One way is to get the initial admin password using command below. The password is base 64 encoded, so if on windows use Git Bash to use the decode function.

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d

This will return the decoded password that can be used directly.

Another way is to patch the argocd-secret and update the admin.password field which should be encrypted with Bcrypt password hashing function. One can use the online tools like bcrypt-generator.com to get the hash.

Here the updated password is admin.

kubectl -n argocd patch secret argocd-secret -p '{"stringData": {"admin.password": "$2a$10$aDulNEmKSuPr8rUH7CvMguvkz/x5wRJuiZgXOw4cc4Zzk2RhpRpBi", "admin.passwordMtime": "'$(date +%FT%T)'"}}'

After login, target page will show the list of application. As there are no applications, so this section is blank for now.

Login using Argo CD CLI

First install Argo CD CLI as per the operating system.

For mac or Linux, use the below command to install it.

brew install argocd

For windows, follow the link, download and add the entry in path variable.

To login through CLI, use the command mentioned below:

argocd login localhost:8081 --username admin --password admin --insecure

Argo CD installation and Login part is completed. Now the next step is to create a demo application and update k8s manifest to deploy in cluster.

The Demo Application

As it already discussed that Argo CD uses git repository to automate the deployment, so a git repository is required. Here I am using github repository.

git clone https://github.com/aprabhat/argo-cd-color-app.git

After cloning, switch to dev branch, check for the deploy folder and take a look at deployment and service manifest files.

Now create another namespace in which the demo application will be deployed.

kubectl create ns practice

Create k8s resource of type Argo CD application using the above repo as source. For this create color-app.yaml file with following content. Here, targetRevision represents the branch name and path represents the location from root directory where the k8s manifest resides.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: color-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/aprabhat/argo-cd-color-app.git
    targetRevision: dev
    path: deploy
  destination:
    server: https://kubernetes.default.svc
    namespace: practice

Save and apply this yaml file.

kubectl apply -f app.yaml

This will create a resource of type application. The new application is now available in Argo CD dashboard.

The app list and status can also be fetched by using Argo CD CLI using argocd app list command.

Click on the app tile in UI and check for the resources created for the application.

The app is created but not deployed as the syncPolicy is not set and default to manual. So a manual synchronization is required.

argocd app sync color-app

Once the sync is completed, the application details UI will also be updated with all the resources created for k8s application.

Now let's update the application to be on auto sync mode. To do so, update the color-app.yaml file for syncPolicy and apply it again using kubectl apply -f color-app.yaml.

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: color-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/aprabhat/argo-cd-color-app.git
    targetRevision: dev
    path: deploy
  destination:
    server: https://kubernetes.default.svc
    namespace: practice
  syncPolicy:
    automated: {}

To test the auto sync, update the deployment.yaml file for replicas and push the change to git repository. Check the application details in Argo CD UI dashboard for the pods if they scaled to 2.

This time as syncPolicy is set to automated, there is no need to do a manual sync.

Finally you can check for the deployed application. First describe the service from practice namespace using kubectl -n practice describe svc color-service

Name:                     color-service
Namespace:                practice
Labels:                   app.kubernetes.io/instance=color-app
Annotations:              <none>
Selector:                 app=color
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.110.20.25
IPs:                      10.110.20.25
LoadBalancer Ingress:     localhost
Port:                     <unset>  3000/TCP
TargetPort:               3000/TCP
NodePort:                 <unset>  30007/TCP
Endpoints:                10.1.0.19:3000,10.1.0.20:3000
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

To access the sample application deployed use the localhost:<NodePort>. In this case it is localhost:30007, open this in the browser. The nice UI will appear on the browser window.

In few simple steps, you are able to automate the deployment of k8s application using Argo CD.

Although this post is not covering all the scenarios or production system use cases but it is a good place to have a glimpse of how Argo CD works and to understand how to automate k8s application deployment with Argo CD.

Conclusion

In the era of microservice, as the number of k8s workloads keeps on increasing, deploying the tens or hundred of pods at the same time is a tedious task.

In this situation, Argo CD is a great tool which enable teams  to automate the deployment on multiple environments(testing, staging production). Argo CD will definitely helps the scrum teams to save time by automating the Continuous Delivery process and reduce common errors.

Java annotation processing JSR 269 is a standardized API to provide allow Java Compiler to runtime validate the code and generate source or byte code.

This provides a way to generate compile time code generation for java projects. Dynamically annotating a class and enhancing or introducing new behavior is a key feature we have seen in frameworks like Spring. While the behavior modification was creation of Proxy around certain Class and provide additional features underneath through Reflection. This feature was created at runtime in Java.

This feature is used by lot of existing java libraries already like Lombok, Mapstruct, Immutables. The JVM based Micronaut Framework is also been written from scratch to improve performance to not just use reflection and rather use compile time code generated, which would improve performance in runtime.

Micronaut introduced reflection-free approach to Dependency Injection and AOP. Framework's key feature is the usage of Annotation Processing which could generate all new functionality at compile-time instead of runtime as in the case of Spring which result in faster startup times.

Lombok goes beyond JSR 269 and adds additional code to modify the internal compiler's AST while JSR 269 was only meant to rather generate a new source code; which in alleged to break without warning when updating to a new compiler version.

While using with microservices, there are times to quickly integrate REST Service into your code. While Java Ecosystem is quite rich with http libraries like Apache HttpClient, OkHttp etc and one of my favourites, the declarative client OpenFeign; we explore the possibility to auto generate a client.

Let's use the code generation feature and auto generate a REST Client Adaptor directly from a public hosted Swagger Documentation - The PetStore 🐕.

Basic Setup

To enable Compile time Annotation Processing we first need need to enable Annotation Processing configuration is your IDE; which would tell your compiler to enable Annotation Processor. If you are using IntelliJ IDEA you can follow link.

We setup a basic gradle project into 2 separate modules:

• library - The Annotation Processor lib
• playground - To test the annotation or your target project of usage

Library Module

In this Module we create a build.gradle with following dependencies

dependencies {
    compile 'io.swagger.parser.v3:swagger-parser:2.0.27'
    compile 'com.squareup:javapoet:1.13.0'
    compile 'com.fasterxml.jackson.core:jackson-core:2.12.5'
    compile 'org.apache.commons:commons-collections4:4.4'
    compile 'org.apache.commons:commons-text:1.9'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

Create a Custom Annotation SwaggerClient which when annotated to a class, would trigger the compilation and in turn leads to generation of any new code.

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface SwaggerClient {
    String location();
}

Enable Annotation Processor via META-INF configuration in this submodule.

To do this, create a file in directory resources/META-INF/services/ named javax.annotation.processing.Processor and add entry for your Annotation Processor classes as FQCN. We would name our annotation processor class as SwaggerClientProcessor . It can have list of Annotation Processors per line.

For us, file's content would be

com.whackd.library.SwaggerClientProcessor

Now, Create the SwaggerClientProcessor Class. This processor class has to be extended from javax.annotation.processing.AbstractProcessor

@SupportedAnnotationTypes("com.whackd.library.SwaggerClient")
@SupportedSourceVersion(SourceVersion.RELEASE_11)
public class SwaggerClientProcessor extends AbstractProcessor {
    private Messager messager;
    private Filer filer;
    private Elements elements;
    private Map markedClasses;
    ...
}

We would have to implement 2 methods: init and process

@Override
public synchronized void init(ProcessingEnvironment pEnv) {
    super.init(pEnv);
    filer = pEnv.getFiler();
    messager = pEnv.getMessager();
    elements = pEnv.getElementUtils();
    markedClasses = new HashMap<>();
}

In the process method, we start processing all classes which are marked with @SwaggerClient annotation.

@Override
public boolean process(Set annotations, RoundEnvironment roundEnv) {
    for (Element element : roundEnv.getElementsAnnotatedWith(SwaggerClient.class)) {
        if (element.getKind() != ElementKind.CLASS) {
            messager.printMessage(Diagnostic.Kind.ERROR, "Can be applied to class.");
            return true;
        }

        TypeElement typeElement = (TypeElement) element;
        markedClasses.put(typeElement.getSimpleName().toString(), element);
    } 
    ...
}

Get the json target url location from Custom Annotation's location property, and start parsing the Swagger Json

Swagger swagger;
try {
    final String location = element.getAnnotation(SwaggerClient.class).location();
    swagger = new Swagger20Parser().read(location, null);
} catch (IOException e) {
    messager.printMessage(Diagnostic.Kind.ERROR, "Error fetching Swagger API Metadata.");
    return true;
}

Now, using JavaPoet library we add code to generate source Java Class by iterating the values from Swagger Parser. Here's small snippet of the code.

final Map definitions = swagger.getDefinitions();
for (Map.Entry pathEntry : swagger.getPaths().entrySet()) {
    String path = pathEntry.getKey();
    Path pathInfo = pathEntry.getValue();
    final List paramKeys = parsePathParams(path);

    for (Map.Entry opsEntry : pathInfo.getOperationMap().entrySet()) {
        HttpMethod httpMethod = opsEntry.getKey();
        Operation operation = opsEntry.getValue();
        List headerParameters = new ArrayList<>();
        List queryParameters = new ArrayList<>();

        MethodSpec.Builder methodBuilder = MethodSpec
                .methodBuilder(operation.getOperationId())
                .addException(Exception.class)
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC);
    ...            

Playground Module

In this module, we simple use the Main class and import our library.gradle submodule.

dependencies {
    implementation project(':library')
    annotationProcessor project(':library')
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

Showdown

Let's start testing the integration for our Custom Annotation @SwaggerClient. We simple mark our project's Main class with required annotation giving Swagger Documentation HTTP url. After adding annotation remember to recompile Main class if auto-generation does not happen. If your compile target has been set to gradle, then recompile the Main class file manually. Our implementation would generate a new class MainClient which would have all methods corresponding to the endpoints of Swagger Documentation.

The compilation of Annotation Processor does not happen on the same JVM as source on which annotation was integration on. Instead it happens separately in a different JVM. Which in turn uses javac to compile all the classes with -processor as a flag. Gradle helps with this compilation using the annotationProcessor DependencyHandler.

annotationProcessor project(':library')

After recompilation, we check the MainClient class generated in the generated sources build directory. It got compiled and added to our build generated sources annotation directory. Cool ! 👍

playground/build/generated/sources/annotationProcessor/java/main/com/whackd/playground/MainClient.java

Now the Magic. We have autocomplete available while coding! This is the exact feature we want to achieve. 👏🏽

Execute it now already 🚀

Concluding this post, code generation is a beautiful idea to automate and speed up your development process. Easier to integrate, makes your teams adhere to single coding style strategy since it is compiled time validated.

No need to spend time on Code reviews, Code creation for new services and Code style changes every time a new integration is required.

JSON Web Token or JWT or sometimes pronounced as 'jot' is an open standard (RFC-7519) for transferring claims in a compact, printable and secure manner along with a signature that provide its authenticity between two parties as a JSON object.

JWTs can be signed using JSON Web Signature (RFC-7515) and/or encrypted using JSON Web Encryption (RFC-7516) and that provides a powerful and secured solution for transferring information in many different situations.

In this section we will focus on unencrypted JWTs, and will take the encrypted one in next part.

Structure of JWT

JWT's contains 3 different components separated by dots(.)

• Header
• Payload
• Signature/Encryption Data

The header and payload are mandatory and have certain structure(JSON). The third part(not a JSON object itself) which is signature depends upon the algorithm used for signing and can be omitted in case of unsecured/unencrypted JWTs.

JWT usage URL safe base64 encoding where '+' and '/' are substituted by '-' and   '_' characters respectively. The resulting sequence is a string with format header.payload.signature and look like the following,

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

In this example, the base64url decoded header is

{
  "alg": "HS256",
  "typ": "JWT"
}

the decoded payload is

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

and the last part is the secret required to verify the signature.

Now lets see the details of mandatory part of JWT which is the header and the payload.

Header

Also known as JOSE(JSON Object Signing and Encryption) Header is the first part of JWT token. There can be several fields in the header depends upon the type of JWT, for example, the only mandatory field for the unencrypted JWT is alg with value as none. For a signed JWTs, some fields can be alg, jku, kid, typ.

The header part is a JSON object and has the following format

{
  "alg": "RS256", // none in case of unencrypted jwt
  "jku": "url to the public key set",
  "kid": "key-id-1", //optional
  "typ": "JWT"
}

It is possible to add additional user defined claims to the header.

Payload

Just like the header, payload is a JSON object. This is the part where all the user related data is added. It can contain claims with specific meaning known as registered claim along with some personal user data, although no claim is mandatory.

There are several reserved claims as per JWT specification that are non mandatory but seven claims are recommended to have for better interoperability. The seven claims are as follows,

• iss (issuer): party that issued the JWT
• sub (subject): Identifies the user
• aud (audience): Recipients of JWT or the application that reading the data from JWT
• exp (expiration time): Time (seconds since epoch) after which the JWT expires
• nbf (not before time): Time (seconds since epoch) from which JWT is considered as valid.
• iat (issued at time): Time at which the JWT was issued
• jti (JWT ID): Unique identifier; can be used to differentiate JWT from similar content.

You can see the complete list of reserved claims here.

Unencrypted JWTs

So far we have learned about the header and the payload part which is enough to construct a unencrypted JWT token.

Unencrypted JWTs formed with simple header

{
  "alg": "none",
  "typ": "JWT"
}

and with payload

{
  "sub": "user108",
  "name": "Shakal",
  "iat": 1629690269
}

now lets create a unencrypted JWT using these two parts. The pseudo code for this would be as follows,

token = base64urlEncode(header) + "." + base64urlEncode(payload) + "."

You can use any coding language to write encode and decode functions. Here I am using java 8 Base64 encoding that is part of JDK

import java.nio.charset.StandardCharsets;
import java.util.Base64;
public String base64urlEncode(String raw) {
    return Base64.getUrlEncoder().withoutPadding().encodeToString(raw.getBytes(StandardCharsets.UTF_8));
}

We also need to remove the trailing equal signs (=), for this we are using the withoutPadding() function. The resulting string will look like

ewogICJhbGciOiAibm9uZSIsCiAgInR5cCI6ICJKV1QiCn0.ewogICJzdWIiOiAidXNlcjEwOCIsCiAgIm5hbWUiOiAiU2hha2FsIiwKICAiaWF0IjogMTYyOTY5MDI2OQp9.

Conclusion

Now we have the basic understanding of structure of JWTs and different parts used to create JWTs. We discussed about the first two parts of JWT which is the header and the payload and created a unsecured JWT.
I real world scenarios, the use of unsecured JWTs is very rare or not at all.

In the next part, we will discuss about encrypted or secured JWTs and have more details on signature part.

Changes on internet have been progressively rapid with more and more usage. Our habits, behavior, work culture, entertainment, interactions have been greatly impacted as a result. With more and more advanced new tech coming up, there is arising a need to create our new desires, likes or dislikes to be quantified and become of value on Internet.

But, the digitalization of data always has been that it can be replicated, duplicated easily which has caused many things on Internet to lose value as soon they are copied to Internet. Any document, media once copied as digital can be copied and share with single Copy Paste operation; which let work or a thing to lose its value.

Any new work of value by Creators around the world have been facing this problem for a while. Music artists, Cinema concerned about their work to be copied and shared on Internet via Private network cause them to lose value and money of their work. A research paper once leaked or shared across Internet with years of work; lose its value in few seconds.

Money not necessary is a just a currency but is a thing of value.

Blockchain has given option to resolve this problem. With Blockchain we can a thing wrapped in a transaction as hash and present on a Blockchain network since unique hash in the chain. Which means none like it exists on the chain and it cannot be modified (or copied) and has been agreed to upon by members on the Blockchain as a valid transaction.

There is no one like me exist on the network.

This has paved a way to have something exist on Internet as a Value (IoV) which can trigger people's desires and can be fulfilled and quantified by a certain value based on it's demand.

This is the concept of Internet of Value and in the form of Non-fungible Tokens (NFTs) which once released by owner Content creators as a value, can be distributed over the Internet or via a marketplace.

In fact. this has been allowed new jobs in the market and people are specifically calling themselves as NFT Artists who would sell their work on Blockchain as NFTs and which can guarantee them money or a Crypto coin as value in return. This allows them to be kings of their work as they create value and also become investors in Blockchain. Arts are being shared as Videos or GIFs or Jpegs.

This is what is being referred to as a Creator Economy. Individuals with more creativity power would be given more value on Internet.

Creators are 👑. Builders are 👑. Developers are 👑

Let's now try to understand the current state of Internet. Most content creation on Internet is build on centralized platforms owned by large corporations. Any thing of value would be taken and accept to by a medium and then would be transferred to target by having certain transaction fee.

Centralized corporations can motivate, unmotivate, allow/disllow your work on Internet. Things that matter to them would be shared and anything else that could be of value would not led to become a thing on its own. Peer-to-Peer networks resolves this by having network connection between then directly.

This involvement of a third-party when transferring something of value is true for Social Media Network Content, Money and even data on chat applications like WhatsApp.

Data provided to a mediator can not be trusted on which they are build making users of unknowingly a part of their data farming.

This however, even technically right now, this needs some improvements in terms of a common protocol in Blockchain to have seamless, interoperable and reliable transaction across different types of currency Blockchain and networks.

As of now developers across the world are more focussed on solving these problems while also trying to come up with new products. There would be some interesting frameworks and new protocols upcoming for sure in near future which possibly would changes the current state of Internet possibly forever.

Till then keep living the curious life 👍🏽.

While the tech world is using words to promote Cryptocurrency as Bitcoin, Ether, Cardano, Polkadot, Dogecoin and a whole lot of buzz and excitement laid over with almost overloaded exchanges of Crypto currency at the moment.

India is not far behind in this race of coin exchanges. In house exchanges like WazirX, CoinDCX, Zebpay, CoinSwitch Kuber and UnoCoin have been around now for a while and have been consistently improving on investment platforms for local market allowing customers to join in the network of least as 10 Rupees of base investment.

Big Celebrity tech innovators like Elon Musk with their single tweets made the market capable enough to invite new and old investors to join in the DogeCoin. Meme marketing as usual in a trend used quite a lot recently for marketing.

While the tech progression in the direction of crypto have been good, however the new investors have found mixed impressions of the exchange platforms because of the quick spiked changes in the exchange rate.

The most likely reason Dogecoin dropped 40% in 24 hours

Dogecoin had a massive drop as other cryptocurrencies fell in the last 24 hours. Why did it drop 40%? Why did Doge face a massive dip?

Deseret NewsHerb Scribner

These sudden drops in recent times have been due to multiple reason, last major being China's grasp on Cryptocurrency banning of miners.

Cryptocurrency as a tech is absolutely fascinating; however the solution to decentralized applications are still limited. One question stayed in place for long is the energy consumption and its impact on environment and climate change. Lot of new solutions to energy consumption has been met with consensus solution like Proof-of-Authority but has been argued to be a centralized network consisting of authorized users.

Another aspect of Cryptocurrency is the base of this technology which is Blockchain.

Blockchain is the source of truth as a chain which cannot be modified and reinforces facts with consensus over the Blockchain P2P network.

Being able to store or reinforce this truth via consensus allows it to create processes that are decentralized over the network. But, this theory of being online as a node in Bitcoin is still not accepted by lot of people as of now. Certainly, there would be hardware upcoming in the market as soon the network and market grows.

Decentralized Applications (DApps) also are labelled as Web3 is also picking as a standalone technology which is not a cryptocurrency based system but shares base technology of Blockchain.

Presence of lot of Social Media platform, be it Twitter, Instagram, Facebook, Snapchat, WhatsApp and even short video driven content based applications like Tiktok has given platform to creators, create their art, content, share thoughts over Social Media easily. Even Youtube has been experimenting with Youtube Shorts as short videos. So much so, that mixed with targeted marketing now creators could directly get monetary benefit to even pursue this as a viable career option. But still factors defining value of a content are vague; which makes usage of these apps limited to lot of users.

Blockchain in the form of NFT (A Non-Fungible Token) allows any content on the Internet to be monetized in itself and have a value of its own. Changing habits and more young generation being on internet makes it possible to have something to exist as a value on internet; whose impact also has been accelerated by Covid-19 making more activity on internet.

These new tech are upcoming and are quickly being experimented with now.

Facebook's Deim, A blockchain based payment system has already been labelled as a digital currency; with now Pontem network in place to carry out transactions. So now any content could possibly be shared with people would be monetized and direct digital purchases can happen in future.

Pontem is an Experimental Network for Diem

Pontem is an Experimental Network for the Diem Blockchain

Recently, Twitter has announced their Social Media network project called 'BlueSky'. Twitter has its own share of controversies to Block or Expand thoughts or Opinions based on its own policies. People with followers also gets paid to make tweets.

Being Decentralized would allow tweets to be available in restricted areas of world even if network is restricted if they are part of blockchain network.

Also, any content now could have a value; only those who want to own or view, pay and get that content data as a value to them.

Twitter’s decentralized social network project finally has a leader

Bluesky, the decentralized social network project funded by Twitter, will be led by Jay Graber, the creator of Happening. Graber announced the new position alongside the news that Bluesky is hiring its first developers.

The VergeIan Carlos Campbell

Tiktok recently integrated Audius as music-streaming platform. So, in turn short videos or funny memes created would have a monetary value which could be possibly purchased or re-sold in the marketplace as a digital content.

Music Streaming Platform Audius Surges 143% on TikTok Integration | Crypto Briefing

Crypto-based music platform Audius has partnered with TikTok, catapulting the AUDIO token up 143% in less than 24 hours.

Crypto BriefingTimothy Craig

Upcoming changes are visible and would hit the internet soon. These changes would make WebApps and developer market change too in terms of skills. Marketing of products could also see this change; as digital marketing could sell or re-sell their ads via platforms.

Most importantly, creators if lost their value on a platform would still be able to hold their work and share it on different platform. This should be the case however, big tech giants might not allow this.

So, if you are a content creator for Tiktok, and its gets a banned in your country, you might not have to cry about it 😀. There is a possibility of open-sourced network to allow platform based transitions like this (looking at you Indian Startups).

Github introduced user display images as Identicons way back in 2013. Github's Identicons are simple 5x5 pixel colored image displaying identity of a user into his display picture.

Initially Identicons were mostly recognized online as Gravatar, short for Globally recognized avatar, sometimes also regarded as digital-fingerprint, is an image which you could generate that would recognize you to any website as an introduction with some basic details.

Gravatar was a service which would let you create a profile with details like your email, image and few basic details and would give you a url which would let you display or embed profile details in any website.

Algorithm takes email as user identity (or IP Address) and create a MD5 hash and then hexify that to generate a string which as a url would recognize the user.

The most basic image request URL looks like this: https://www.gravatar.com/avatar/{HASH}

where HASH is replaced with the calculated hash for the specific email address you are requesting. This URL generated could be used as an IMG tag to display user image:

https://www.gravatar.com/avatar/205e460b479e2e5b48aec07710c08d50

In this post, we would generate user identicon in Github's style; which could be used further to generate user images to identicons as service, into your projects.

Github Identicon Algorithm

Take a user identifier (say email), hash it SHA1 and then convert it to hex binary. Then in order to create a symmetric image rotate it and then mirror the matrix.

Input => someone@email.com (User Identity)

fn MD5Hex(_) => 23adaae0eafc12761c29d920c5da1aa8
// then
fn toInt16(_) => 47424713038463833496632231788185000616
// then
fn toBinary15Limit(_) => 001101010101000

Resultant matrix can be used to draw an image with color pixel on position where pixel value is 1. If you have noticed, we have just expressed the user identifier in a 2D domain.

Generating Identicon Matrix

Now we can use any drawing library like Canvas in NodeJS or PIL(Pillow) in Python to draw the identicon. Let's do this via NodeJS Canvas API. Here's the snippet to generate image from matrix.

const { createCanvas } = require('canvas');
const fs = require('fs');

const SIZE = 350;
const matrix = [
    [0, 1, 0, 1, 0],
    [0, 0, 1, 0, 0],
    [1, 1, 0, 1, 1],
    [1, 0, 0, 0, 1],
    [0, 1, 0, 1, 0]];
const canvas = createCanvas(SIZE, SIZE);

const ctx = canvas.getContext('2d');
ctx.fillStyle = '#f2f2f2';
ctx.fillRect(0, 0, canvas.width, canvas.height);

for (let i = 0; i < matrix.length; i++) {
    for (let j = 0; j < matrix[i].length; j++) {
        if (matrix[i][j] === 1) {
            ctx.fillStyle = '#03a4f4';
            ctx.fillRect((j + 1) * 50, (i + 1) * 50, 50, 50);
        }
    }
}

fs.writeFileSync('out.png', canvas.toBuffer());

Hope you liked the post. Cheers!

Created by Ryan Dahl NodeJS first came into being in May 27, 2009, NodeJS is traditionally seen as a single threaded asynchronous engine. Single threaded async engine created from Chrome V8's engine that could perform as a backend engine.

For its design, the V8 engine was preferred to be used as an I/O performant and not as a CPU performant backend. However, NodeJS Team has been working towards making NodeJS to work with threads too.

Even in Web Browsers, Web Worker API provides a way to create background task that could be run simultaneously from browser window scope so that it wouldn't block single-threaded engines when we would like to perform a CPU bound task. We would discuss Web Workers are a topic to be discussed in future posts. Let's get back to Worker Threads.

First introduced to NodeJS in version v10.5.0 with experimental feature, Worker Threads, with version v12 LTS API became stable and ready to use in production.

Basic Introduction to API

Worker Threads can be imported to NodeJS as simple as

const worker = require('worker_threads');

And then, create a Worker Thread Object as

const worker = new Worker(__filename)

The Worker class represents an independent JavaScript execution thread. The __filename can be the same javascript file or a target javascript file to load with new thread created.

The Worker Object also accepts other values in its constructor one of which is workerData. Let's see an example of a script that would create a new thread from its main thread and can process initialised data via workerData passed inside the constructor.

const {
  Worker, isMainThread, parentPort, workerData
} = require('worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename, {
    workerData: content
  });
} else {
  const { lib } = require('some-js-library');
  
  // workerData available to be processed
}

isMainThread tells the code that if the code is running in main thread or not. Here, we have created the worker instance and passed some content to its constructor via workerData. Since worker is create with same file location it would be also be loaded via Worker Thread inside a new thread and pass content data would be available to us in thread via workerData value imported.

Inter-Thread Communication

Two-way communication can be achieved through inter-thread message passing. Worker Threads supported MessageChannel which exposes MessagePort objects as port1 and port2 for sending and receiving. Here is a code snippet.

const assert = require('assert');
const {
  Worker, MessageChannel, MessagePort, isMainThread, parentPort
} = require('worker_threads');

if (isMainThread) {
  const worker = new Worker(__filename);
  const channel = new MessageChannel();
  
  worker.postMessage({ hereIsYourPort: channel.port1 }, [channel.port1]);
  channel.port2.on('message', (value) => {
    console.log('received:', value);
  });
} else {
  parentPort.once('message', (value) => {
    assert(value.hereIsYourPort instanceof MessagePort);
    value.hereIsYourPort.postMessage('the worker is sending this');
    value.hereIsYourPort.close();
  });
}

The API is very simple and easy to understand on its own. Since concept of threads comes with a lot of caveats we would discuss those in following blog posts.

Next, we would analyse a use case for task break down into threads and see how we can improve performance of certain CPU intensive tasks via Worker Threads in NodeJS.

Stay Tuned...