Ricardo Ferreira

Getting Started with the MCP Server for Redis Cloud using Docker

Thu, 19 Mar 2026 00:00:00 +0000

A getting-started guide to running the Model Context Protocol (MCP) server for Redis Cloud in Docker, so AI assistants can work directly with your Redis data.

To Vector, or not to Vector, that is the Question

Mon, 24 Nov 2025 00:00:00 +0000

This year, I presented a session at the All Things Open conference called To Vector, or not to Vector, that is the Question, and I found myself facing a packed room with people standing in the back. The topic? Whether you actually need a vector database. It seems I wasn’t the only one struggling with this question. This session was very well received, and the most unanimous feedback I received after the session was whether a blog about this session would be written or not.

To Vector, or not to Vector, that is the Question

Mon, 13 Oct 2025 00:00:00 +0000

A data-driven framework for making smart decisions about vector databases. This session explores when you actually need a vector database and when a simpler solution wins, covering the hidden costs of embeddings, infrastructure, and debugging.

An Alexa Skill that Recalls All Memories

Tue, 30 Sep 2025 00:00:00 +0000

A short demo of an Alexa skill that stores and recalls memories on demand, showing how voice interfaces can front a simple memory store.

Vector Database Search: HNSW Algorithm Explained

Mon, 28 Jul 2025 00:00:00 +0000

A walkthrough of how the Hierarchical Navigable Small World (HNSW) algorithm powers fast approximate nearest-neighbor search in vector databases, and why it strikes such a good balance between speed and accuracy.

Is Your Vector Database Really Fast?

Mon, 21 Jul 2025 00:00:00 +0000

Not all vector databases are as fast as their benchmarks claim. This video digs into what actually determines vector search performance and how to measure it honestly for your own workload.

What is Filtered Search?

Tue, 15 Jul 2025 00:00:00 +0000

A short introduction to filtered search: how to combine metadata filters with vector similarity so you retrieve results that are both semantically relevant and constrained to the right subset of your data.

What is Hybrid Search?

Fri, 04 Jul 2025 00:00:00 +0000

An explanation of hybrid search, which blends traditional keyword (lexical) matching with vector similarity to get the best of both worlds when building retrieval systems.

Chunking Strategies Explained

Fri, 27 Jun 2025 00:00:00 +0000

How you split your documents into chunks has a big impact on retrieval quality. This video breaks down the common chunking strategies and when to reach for each one.

Long-Term Memory with LangGraph

Mon, 12 May 2025 00:00:00 +0000

A deep look at implementing long-term memory in agentic applications with LangGraph, so your agents can retain and recall information across sessions.

Short-Term Memory with LangGraph

Mon, 05 May 2025 00:00:00 +0000

How to give your LangGraph agents short-term memory, letting them keep track of context within a conversation or task before it is persisted or discarded.

Create a New Database on Redis Cloud

Sat, 08 Mar 2025 00:00:00 +0000

A step-by-step walkthrough of creating a new database on Redis Cloud to back your applications.

Similarity Search using Vector Store

Fri, 07 Mar 2025 00:00:00 +0000

Implementing similarity search over embeddings using a vector store to power retrieval in AI apps.

A Semantic Cache using LangChain

Thu, 06 Mar 2025 00:00:00 +0000

Building a semantic cache with LangChain and Redis to avoid redundant LLM calls for similar queries.

LLM Session Management with Redis

Wed, 05 Mar 2025 00:00:00 +0000

How to manage LLM conversation sessions using Redis to persist and retrieve chat state.

Resources to Learn AI with Redis

Tue, 04 Mar 2025 00:00:00 +0000

A roundup of resources to help you get started learning AI development with Redis.

Building AI Apps using LangChain

Mon, 03 Mar 2025 00:00:00 +0000

A short intro to a series on building AI applications with LangChain and Redis.

The Engineering Wisdom Behind Redis's Single-Threaded Design

Thu, 27 Feb 2025 00:00:00 +0000

In the relentless pursuit of performance, our industry often gravitates toward seemingly obvious solutions: more cores, more threads, more concurrency. Yet Redis—one of the most performant databases in the world—has maintained its commitment to a primarily single-threaded execution model. As various Redis forks emerge claiming dramatic performance improvements through multi-threading, I want to explore why Redis’s core architectural choices remain fundamentally sound, even at scale.

Counterintuitive Brilliance of Single-Threaded Design

When Salvatore Sanfilippo designed Redis, he made a choice that seemed to contradict conventional wisdom: a single-threaded event loop at the core of a high-performance database. This wasn’t a limitation to be overcome—it was a deliberate architectural decision that eliminated entire classes of complexity:

Redis Insight: A Developer's Deep Dive

Tue, 18 Feb 2025 00:00:00 +0000

A hands-on deep dive into Redis Insight, the GUI for exploring, debugging, and optimizing your Redis data from a developer’s perspective.

What AI Coding Assistants Have in Common with iRobot Roomba?

Sun, 05 Jan 2025 00:00:00 +0000

In 2010, I purchased my first iRobot Roomba, the 700 series model launched that year. It promised to revolutionize automated cleaning, a claim repeatedly made since the device’s initial release in 2002. Unaware of previous models’ shortcomings, I was captivated by the promises of this new version. I recall reading about patented features like the Dirt Detect Technology™ and built-in integration with voice assistants. All of which seemed incredibly innovative at the time.

Getting Started with the VSCode Extension for Redis

Mon, 16 Dec 2024 00:00:00 +0000

A getting-started guide to the Redis extension for Visual Studio Code, so you can browse keys and run commands against Redis without leaving your editor.

Getting Started with Amazon Q Developer Customizations

Wed, 17 Jul 2024 00:00:00 +0000

An introduction to Amazon Q Developer customizations, which let you tailor code suggestions to your organization’s own codebase and conventions.

Sending Traces to AWS X-Ray Using Amazon Q Developer

Thu, 16 May 2024 00:00:00 +0000

A practical example of using Amazon Q Developer to instrument an application and send distributed traces to AWS X-Ray.

Implementing an OpenTelemetry Collector Using Amazon Q Developer

Wed, 15 May 2024 00:00:00 +0000

Walking through how to stand up an OpenTelemetry Collector with the help of Amazon Q Developer, from configuration to running pipelines.

Using Amazon Q Developer to Write Code for Observability

Tue, 14 May 2024 00:00:00 +0000

How Amazon Q Developer can accelerate writing observability code, generating the instrumentation and boilerplate so you can focus on what to measure.

Deep Dive into the Queue Data Structure

Thu, 19 Oct 2023 00:00:00 +0000

A detailed exploration of queues: FIFO semantics, common implementations, and where they fit in real-world systems.

Developing Java Applications using Amazon Bedrock

Tue, 17 Oct 2023 00:00:00 +0000

A guide to building Java applications on top of Amazon Bedrock, connecting your code to foundation models through the AWS SDK.

Deep Dive into the Linked List Data Structure

Thu, 05 Oct 2023 00:00:00 +0000

A deep dive into linked lists: singly and doubly linked variants, their trade-offs against arrays, and the operations that make them shine.

Deep Dive into the Array Data Structure

Fri, 29 Sep 2023 00:00:00 +0000

A thorough deep dive into arrays: how they are laid out in memory, their performance characteristics, and the operations they support.

Deep Dive into the Matrix Data Structure

Fri, 29 Sep 2023 00:00:00 +0000

An in-depth look at matrices as a data structure, covering representation, traversal, and the common operations you will encounter.

Learning Data Structures with Amazon CodeWhisperer

Fri, 29 Sep 2023 00:00:00 +0000

Using Amazon CodeWhisperer as a pair-programming companion to learn and implement classic data structures from scratch.

AWS Databases: Use Cases and Optimizations

Thu, 13 Jul 2023 00:00:00 +0000

An overview of the AWS database portfolio, matching common use cases to the right service and sharing optimization tips along the way.

A Three-Minute Summary of What to Consider When Choosing Databases

Tue, 20 Jun 2023 00:00:00 +0000

A quick, three-minute summary of the key trade-offs to weigh when choosing a database for your workload.

The Right Number of Partitions for a Kafka Topic

Tue, 04 Apr 2023 00:00:00 +0000

Every technology has that key concept that people struggle to understand. With databases, is which join clause to use for fetching data from multiple tables. Containers are tricky when you have to pick a storage type given some persistence requirements. With Apache Kafka, the winner is how many partitions to set for a topic. Why this is important? You may ask. Well, sizing Kafka partitions wrongly affects many aspects of the system, such as storage, parallelism, and durability. Worse, it may also affect how much load Kafka can handle. Hence why often the decision about how many partitions to set for a topic is handled by Ops teams, as we see this to be only an infrastructure matter. In reality, this is an architectural design decision that affects even the amount of code you write. This session will peel off the concept of partitions and explain it from the perspective of the Kafka cluster and its clients. It will explain the formula people should use to decide how many partitions to set for a topic, and how to spot a poor decision when they see one.

Changing the Backend to AWS with No Code Changes

Mon, 14 Nov 2022 00:00:00 +0000

Switching your telemetry backend to AWS without touching application code, thanks to the Collector.

Sending the Generated Metrics to Prometheus and Grafana

Sun, 13 Nov 2022 00:00:00 +0000

Exporting OpenTelemetry metrics to Prometheus and visualizing them in Grafana dashboards.

Creating Custom Metrics with the OpenTelemetry SDK for Java

Sat, 12 Nov 2022 00:00:00 +0000

How to define and record custom metrics in Java applications using the OpenTelemetry SDK.

Sending Generated Traces to Grafana Tempo

Fri, 11 Nov 2022 00:00:00 +0000

Configuring your pipeline to send OpenTelemetry traces to Grafana Tempo for storage and querying.

Getting Started with the OpenTelemetry Collector

Thu, 10 Nov 2022 00:00:00 +0000

An introduction to the OpenTelemetry Collector: receiving, processing, and exporting telemetry data.

Automatic Instrumentation with the OpenTelemetry Agent

Wed, 09 Nov 2022 00:00:00 +0000

Using the OpenTelemetry Java agent to automatically instrument your application with zero code changes.

Creating Custom Traces with the OpenTelemetry SDK for Java

Tue, 08 Nov 2022 00:00:00 +0000

How to create custom spans and traces in Java using the OpenTelemetry SDK for fine-grained visibility.

Instrumenting Java Applications using OpenTelemetry

Mon, 07 Nov 2022 00:00:00 +0000

The start of a series on instrumenting Java applications with OpenTelemetry to capture traces and metrics.

When Kafka is the source of truth; schemas become your source of headaches

Tue, 04 Oct 2022 00:00:00 +0000

One of the coolest things about streaming systems such as Apache Kafka is their ability to handle any type of data. You can store events at Kafka and have different systems processing their event data. You may start with a few systems and add new systems as needed. While certainly possible and attractive, this isn’t simple. Schemas play a key role in how each system consumes the event data and processes them. Reason Schema Registry exists, right? Not really. Schema Registry doesn’t solve any of your data problems. It’s just a registry for your schemas. Admittedly, without it, there would be no policy enforcement. However, data problems can still happen. Issues with encoding, format mismatch between different programming languages, new code not being able to read data written by old code, etc. In this session, we will get into the weeds of data serialization with schemas. We will discuss the differences between formats like JSON, Avro, Thrift, and Protocol Buffers, and how your code must use each one of them to serialize data. It will also clarify the impact of switching Schema Registry with other registries, and whether you can use them together. If you ever wondered why your Python code can’t read something written by Java, why integers are getting confused with strings, or simply how schemas end up in Schema Registry, this session is for you.

In the land of the sizing, the one-partition Kafka topic is king

Wed, 21 Sep 2022 00:00:00 +0000

Every technology has that key concept that people struggle to understand. With databases, is which join clause to use for fetching data from multiple tables. Containers are tricky when you have to pick a storage type given some persistence requirements. With Apache Kafka, the winner is how many partitions to set for a topic. Why this is important? You may ask. Well, sizing Kafka partitions wrongly affects many aspects of the system, such as consistency, concurrency, and durability. Worse, it may also affect how much load Kafka can handle. Hence why often the decision about how many partitions to set for a topic is handled by Ops teams, as we see this to be only an infrastructure matter. In reality, this is an architectural design decision that affects even the amount of code you write. This session will peel off the concept of partitions and explain it from the perspective of the Kafka cluster and its clients. By using a what-if presentation style, it will explain the overall impact on the system given a number. This will help you build more confidence about how to size Kafka partitions correctly, and to spot a poor decision when you see one.

Is Using KoP (Kafka-On-Pulsar) a Good Idea?

Thu, 18 Aug 2022 00:00:00 +0000

Building microservices around Apache Kafka is your job, and life is great. One day, you hear community members talking about some neat Apache Pulsar features, and get you intrigued. I mean, we all love Kafka, but you can’t avoid wondering if migrate one of your projects to Pulsar is a good idea. Then it happens. You find Pulsar supports Kafka clients natively via a protocol handler called KoP: Kafka-On-Pulsar. This gets you pumped. Is that it? Can I go ahead and simply point my microservices to Pulsar and be a hero with this migration? But you must be responsible; and history says you shouldn’t believe migrations like this are refactoring free. Reason you may get interested in this session. We will revisit the architecture behind protocol handlers to understand what it means having one enabled on Pulsar. Plus, we will discuss the internals of KoP. Finally, we will use a show-and-tell approach to detail the effort to migrate a microservice written for Kafka to Pulsar, and whether the code need to change for this.

Do It Yourself: Programmable Metrics using OpenTelemetry

Tue, 14 Jun 2022 00:00:00 +0000

Using metrics to measure how good or bad things are going is a proven way to ensure a software-based system is going in the right direction. Most metrics are created and monitored automatically by agent technologies installed in our infrastructure, making us hostages of the set of metrics that these agents are programmed to address. But what if you need to handle your own set of metrics? This is a question that often drives developers mad because they fear spending development cycles building something that will end up being locked into a particular monitoring/observability vendor. But OpenTelemetry — a CNCF observability framework that provides a vendor-neutral approach to tackle metrics, logging, and tracing needs, can change everything. This talk will explain how the OpenTelemetry framework allows the creation of custom metrics in a standard, scalable, and reusable way. It will provide an example in Java of a set of metrics that are continuously updated based on the execution of the code and how to hook that data with a compatible observability backend.

Distributed Tracing: The good, The Bad, and the Ugly

Tue, 24 May 2022 00:00:00 +0000

Let’s face it: most people talking about observability all end up talking about distributed tracing somehow. It is a technology that radically changes how we identify and solve technical problems. In a world where virtually all applications are born distributed — it seems to be something that you ought to know in more detail. This talk will provide a pragmatic overview of distributed tracing by clearly articulating its motivation, problems it solves, the challenges, and what technologies you should use to ensure a vendor-agnostic implementation. It will discuss things like white-box and black-box instrumentation, the pros and cons of each approach, and why most developers prefer one versus the other.

How to Create more Effective Developer Content

Thu, 24 Mar 2022 00:00:00 +0000

Let’s say you create developer content for a living. In that case, chances are that you work in one of those fancy jobs titles like Developer Advocacy, Community Management, Product Technical Marketing, Program Management, and many others. Regardless of your title, what is essential is for you to apply effectiveness to your content, which means that you do want that your content targets the right audience and be as relevant as possible. This blog post will discuss how you can accomplish this by using a technique that I affectionately call the 🔺 triangle. This technique is about making your content focus on the different ways people learn, creating the appropriate relevancy by linking them together, and helping scale the content promotion.

The Subtle Art of Giving Code Walkthrough Talks

Mon, 08 Nov 2021 00:00:00 +0000

If your audience is developers, then there is a high chance that you will need to show how code works in one of your talks. While you can always play safe and show snippets of code through slides — giving people code walkthroughs is often a more effective method to see the code where it really matters: in the development environment. But doing so can be a daunting task. Not so much because you may not know the code — but because now your content is the code. So many moving parts now need to be addressed by your code walkthrough, the talk’s timing, how much the audience will absorb, the outcomes you want people to have, and how exciting your talk will be if using this method. In this talk, Ricardo will explain what best practices you should follow to nail your following code walkthrough, so your talk becomes memorable. It will do it by providing an utterly wrong code walkthrough example that will be polished during the talk to highlight each best practice.

What is Distributed Tracing, and Why Should you Care About it?

Mon, 18 Oct 2021 00:00:00 +0000

Let’s face it: most people talking about o11y (observability) all end up talking about distributed tracing somehow. It is a technology that is radically changing the way we identify and solve technical problems. In a world where virtually all applications are born distributed — it seems to be something that you as an SRE ought to know in more detail. This talk will provide a pragmatic overview of distributed tracing by clearly articulating its motivation, problems it solves, the challenges, technologies you should use to ensure a vendor-agnostic implementation, and which aspects you should consider while picking an o11y backend. While discussing the challenges, this talk will highlight white-box versus black-box instrumentation, which is valuable knowledge to determine where the developer’s responsibility finishes and when the Ops team starts, and — when both team’s responsibilities may entangle.

Take me Down to the Paradise City Where the Metric is Green and Traces are Pretty

Tue, 12 Oct 2021 00:00:00 +0000

Observability is a software discipline that goes back to when virtually any problem could be solved by tailing web server logs. But the world has changed, and systems these days are comprised of different services running in their own stacks who cooperatively build up what we understand as the end-to-end architecture. Thus, observability had to evolve as well. Today we have OpenTelemetry—an observability framework for cloud-native software. OpenTelemetry provides the tools, APIs, and SDKs to create a reusable, robust, and non-vendor-driven observability strategy. But the reality is that most developers are still confused about the lines that separate OpenTelemetry from the past and which parts of the framework are stable enough to be used in production. This talk will explain how OpenTelemetry works and provide examples in Java and Go to illustrate the APIs you can use to produce traces and metrics.

Writing Custom Sink Connectors for Pulsar I/O

Wed, 06 Oct 2021 00:00:00 +0000

You currently have massive amounts of data sitting on Apache Pulsar and likely — even more data coming in every second. But part of your project requires this data to be sent to some system to explore the dataset further. You look into the Pulsar website for built-in connectors to that particular system and realize that there are none. What a bummer. But you don’t have to give up on Pulsar because of this. You can write custom sink connectors for Pulsar I/O that work just like the built-in ones, and all you will need is a bit of Java development experience and creativity. The rest you can leave to this talk. This talk will explain how to start developing your custom connector, show how the code looks like, demonstrate how to deploy, and discuss some of the design decisions that your custom connector may need to address.

Boosting your Tests with Elasticsearch using TestContainers-Go

Thu, 30 Sep 2021 00:00:00 +0000

TestContainers is a popular framework that allows Java developers to create tests that depend on backend systems such as Elasticsearch. It automatically creates a container instance for the said backend, preventing developers from manually spinning up their dependency instances. Also, it enables them to treat those instances as disposable, meaning that once the tests finish executing, the underlying containers created for the instances are destroyed automatically.

The good news for Go developers is that there is a version of this for them as well. It is called TestContainers-Go. In this post, I will walk you through creating a simple test that connects with Elasticsearch using this framework.

Elasticsearch for Gophers

Tue, 03 Aug 2021 00:00:00 +0000

Join us as Elastic Developer Advocate Ricardo Ferreira demos how to index, query, search, and aggregate data using the Elasticsearch Client for Go.

Ultimate Guide to the Terraform Provider for Elastic

Fri, 16 Jul 2021 00:00:00 +0000

Most developers deploy their Elastic (Elasticsearch and Kibana) clusters manually by copying the bits to the target system or semi-manually using containers. This might work well if you need to maintain few clusters for your company, where likely you know the name of each one from the top of your head. However, this approach doesn’t scale very well if you have to spin up clusters on-demand for seasonal requirements.

How to Check SSL Certificate Expiration

Mon, 28 Jun 2021 00:00:00 +0000

Using Heartbeat to monitor SSL certificate expiration so you are alerted before certificates lapse.

Adding Geo-Information to Heartbeat Monitors

Sun, 27 Jun 2021 00:00:00 +0000

Enriching Heartbeat monitors with geo-information so you can see availability from a geographic perspective.

Heartbeat Command-Line Options

Sat, 26 Jun 2021 00:00:00 +0000

A look at Heartbeat’s command-line options and how to use them to control its behavior.

How to Download, Install & Configure Heartbeat

Fri, 25 Jun 2021 00:00:00 +0000

A getting-started guide to downloading, installing, and configuring Heartbeat for uptime monitoring.

Monitoring Docker Containers with Autodiscover

Thu, 24 Jun 2021 00:00:00 +0000

How to use Heartbeat’s autodiscover feature to automatically monitor Docker containers as they come and go.

Everything you Always Wanted to Know about Heartbeat

Wed, 23 Jun 2021 00:00:00 +0000

The opening video of a series on Heartbeat, Elastic’s uptime and availability monitoring shipper.

Down to the Rabbit Hole with Pulsar I/O

Wed, 16 Jun 2021 00:00:00 +0000

Apache Pulsar is a distributed messaging and streaming platform that stores messages durably and scalably into its persistent store, making it an attractive technology to store business data. However, merely storing the data is not enough. To make this data useful, the platform must also provide ways to ingest new data and send existing data elsewhere. While developers can build applications for this using the client libraries, the reality is that most of them don’t want to spend time writing code for repeatable tasks such as — reading data from a database and storing it into Pulsar. Reason why Pulsar abstracts away things like this by providing a connector-based framework called Pulsar I/O. This talk will provide an overview of how the Pulsar I/O framework works and a deep dive into troubleshooting things — from identifying when the connector is not working correctly to more elaborating investigations that may be useful for debugging purposes. It will give you the required tools to master how to ingest and export data into and out of Pulsar effectively.

Hidden Secrets about Instrumenting JVMs for OpenTelemetry

Wed, 16 Jun 2021 00:00:00 +0000

OpenTelemetry is the new-kid-on-the-block in API to instrument distributed applications to send telemetry data (logs, metrics, and traces) to backends for visualization and monitoring. It was created to be a de-facto replacement to standards such as OpenTracing and OpenCensus. The support for Java in OpenTelemetry is generous. It supports both automatic and manual instrumentation. With automatic instrumentation, developers can have known libraries and frameworks instrumented without writing a single code line. Manual support also allows them to decide which parts of the code need instrumentation, and there is a rich set of APIs available to use. This talk will open the pandora box for both options. It will reveal which knobs are available to use that make a tremendous difference in how the applications report telemetry data — both in terms of performance and details. Knowing these hidden secrets will grant developers fine control over their applications and how observability stacks show them to the world.

Building Observable Streaming Systems with OpenTelemetry

Mon, 14 Jun 2021 00:00:00 +0000

Building streaming systems is a popular way for developers to implement applications that react to data changes and process events as they happen. It is an exciting new world that technologies like Apache Pulsar made available for anyone to use. But all this goodness doesn’t come for free. One of the challenges of this type of architecture is that its distributed nature makes it hard and sometimes even impossible to identify the root cause of problems quickly. That is why distributed tracing technologies are so important. By gluing together disparate services into a single and cohesive transaction, developers can provide to the operations team a way to pragmatically observe the system and to quickly identify the root cause of problems such as slowness and unavailability. This talk will explain how to implement distributed tracing in Pulsar applications using OpenTelemetry—an observability framework for cloud-native software. A demo will be used to clarify the concepts.

OpenTelemetry for Dummies: Instrumenting Go Apps

Wed, 26 May 2021 00:00:00 +0000

Though tracing technologies are not necessarily a new concept only in the recent years it gained enough traction to become one of the key dimensions required to build observability stacks. Undoubtedly the major force behind this traction are the standards created to help developers to collect telemetry data from their applications, such as OpenTelemetry—an observability framework for cloud-native software. OpenTelemetry provides a single set of APIs, libraries, agents, and collectors that ensures technology agnostic collection of traces and metrics—but the implementation for each programming language is different. While Java has an agent capable of automatically instrumenting the JVM with additional bytecode, other programming languages like Go have to handle this instrumentation manually. But Go developers have nothing to fear. This talk will explain in a for-the-rest-of-us style how to instrument applications written in Go and how to send the telemetry data to a backend using a collector.

Metricbeat Modules: Collecting and Visualizing Metrics from Redis

Fri, 07 May 2021 00:00:00 +0000

Using the Metricbeat Redis module to collect and visualize Redis metrics in Kibana.

Metricbeat Modules: How to Speed Things Up with your Deployment

Thu, 06 May 2021 00:00:00 +0000

Tips for speeding up your Metricbeat deployment when working with modules at scale.

Implementing Metric Data Processing: Handling Data with Logstash

Wed, 05 May 2021 00:00:00 +0000

Routing Metricbeat data through Logstash to apply richer transformations before indexing.

Implementing Metric Data Processing: Handling Data with an Ingest Pipeline

Tue, 04 May 2021 00:00:00 +0000

Processing metric data server-side using an Elasticsearch ingest pipeline instead of doing it at the shipper.

Implementing Metric Data Processing: Using Processors with Metricbeat

Mon, 03 May 2021 00:00:00 +0000

How to use Metricbeat processors to enrich, filter, and transform metrics at the edge before shipping them.

Stop being a hero to become a great developer advocate

Mon, 03 May 2021 00:00:00 +0000

If you ask anyone what a developer advocate is, they will probably describe some hero. Someone is often adored by people in conferences with a packed room waiting to hear what they have to say — because they are deemed simply the best in what they do. Almost as if what they do is the result of having superpowers. By all means, I’m afraid I have to disagree with this definition.

Implementing Metric Data Processing: Overview of the Possible Strategies

Sun, 02 May 2021 00:00:00 +0000

An overview of the different strategies available for processing metric data before it reaches its destination.

Getting Started with Metricbeat: Command-Line Options and Outputs

Sat, 01 May 2021 00:00:00 +0000

Exploring Metricbeat’s command-line options and how to configure where your collected metrics are sent.

Getting Started with Metricbeat: Files & Configuration Options

Fri, 30 Apr 2021 00:00:00 +0000

A tour of the Metricbeat configuration files and the options you will most commonly need to tune.

Getting Started with Metricbeat: Downloading, Installing, and Using

Thu, 29 Apr 2021 00:00:00 +0000

A getting-started walkthrough covering how to download, install, and run Metricbeat for the first time.

Metricbeat Introduction: Metricbeat, Modules & Metricsets

Wed, 28 Apr 2021 00:00:00 +0000

An introduction to the core concepts of Metricbeat: how modules and metricsets fit together to gather metrics.

Metricbeat Modules: Collecting and Visualizing Metrics from Kafka

Tue, 27 Apr 2021 00:00:00 +0000

How to use the Metricbeat Kafka module to collect broker and topic metrics and visualize them in Kibana.

Everything you Always Wanted to Know about Metricbeat

Mon, 26 Apr 2021 00:00:00 +0000

The kickoff to a full series on Metricbeat, Elastic’s lightweight shipper for collecting metrics from your systems and services.

The Best Advice New Developer Advocates Should Follow

Mon, 22 Mar 2021 00:00:00 +0000

There is no denying that the demand for developer advocacy is peaking. Everywhere I go, I can see a huge demand for developer advocates, and this is awesome because this is the career that I chose for myself. But other than this, it is also proof that companies finally realize the value of improving developer experience in the products they offer. As such, this current spike for developer advocates is also a problem. This is not a simple career path to get started with.

How to Help People in Community Forums Like a Boss

Thu, 04 Mar 2021 00:00:00 +0000

Whether it is part of your job description or not, helping users in community forums is always a great idea if you work for a company representing a given technology, product, or service. The key idea is to make sure that users don’t struggle.

But how do you know when and how users are struggling? Well, there are arguably many sources where you can get this information from, such as your support channel, your partners, and your consultancy department, if there is any. Just talk to them periodically and understand where the customers struggle the most. But another one that is becoming fundamental in today’s industry is community forums.

Using Stream Deck with Fedora

Sun, 07 Feb 2021 00:00:00 +0000

I have lost count of how many times I had to apply workarounds in my Fedora laptop to use certain devices. For all of you that had to go down the same path, you know the feeling of hopelessness. The reason why I never get tired of helping people with the challenges I have. This post will describe my journey to get the Elgato Stream Deck device working like a charm on my laptop.

Getting Started with OpenTelemetry using Elastic APM

Mon, 16 Nov 2020 00:00:00 +0000

OpenTelemetry is an observability framework that provides the libraries, agents, and other components that you need to capture telemetry from your services so that you can better observe, manage, and debug them. It allows you to capture metrics, distributed traces, resource metadata, and logs (logging support is incubating now) from your backend and client applications and then sends this data to backends like Elastic APM.

As you probably have heard of at this point OpenTelemetry is the result of the merge between OpenTracing and OpenCensus, and it aims to provide a more complete, vendor neutral, easy-to-use framework to implement your observability needs.

Excluding Files from a List in Terraform

Sat, 10 Oct 2020 00:00:00 +0000

Since the introduction of the for_each feature in Terraform 0.12 it is now possible to code powerful constructs to express the logic of your infrastructure. But sometimes you have to use some creativity to use this feature. I recently had to write a Terraform code that could upload all the JavaScript files from a local folder into a storage blob in Azure. But one of these files would have some template expressions so I wanted to upload all the files from the local folder except that one — because I would upload it individually.

Understanding Streaming Data and Analytics with Apache Kafka®

Fri, 02 Oct 2020 00:00:00 +0000

Slides of the session “Understanding Streaming Data and Analytics with Kafka” that I delivered on ApacheCon 2020. Have fun ✨

https://speakerdeck.com/riferrei/understanding-streaming-data-and-analytics-with-apache-kafka-r

Troubleshooting 101

Fri, 31 Jul 2020 00:00:00 +0000

Part of my job as Developer Advocate is to reach out to developers in social forums like Stackoverflow, Reddit, and Slack communities to check whether I can provide help. While I feel great pleasure in doing this, it is getting harder and harder to help people these days.

I have the feeling that developers these days don’t know (or perhaps forgot or pretend that they forgot) how to perform basic troubleshooting. Every time I see a request for help in a forum usually people barely explain what the problem is, how it occurs, give evidence of what happened before the incident and, more importantly, to provide a minimal explanation of their environment.

Data Sharing between Java & Go using Kafka and Protobuf

Thu, 09 Jul 2020 00:00:00 +0000

One of the most incredible things in Apache Kafka is that record values are shapeless, meaning that developers can write any set of bytes they want, and it works just fine. This can be pretty powerful if they share data among different programming languages.

However, this characteristic is sometimes inadequate. It creates coupling problems as producers and consumers need to negotiate a common format that they can rely on to write and read data. Therefore, it is essential to use a neutral format – likely something accepted within the industry, such as Avro, Protobuf, and JSON Schemas. This post will focus on the problems raised by using Protobuf to share data between Java and Go.

What Apache Kafka has in Common with Rocky Balboa?

Fri, 03 Apr 2020 00:00:00 +0000

If you know me well, you must know that I am a big fan of movies. It is not uncommon to see me in situations where if I need to explain something rather complex, I end up using movies as metaphors to understand what I am trying to explain. In this post, I will explain what Apache Kafka has in common with the character Rocky Balboa.

Why the property 'auto.create.topics.enable' is disabled in Confluent Cloud?

Tue, 17 Mar 2020 00:00:00 +0000

If you ever used Apache Kafka you may know that in the broker configuration file there is a property named auto.create.topics.enable that allows topics to be automatically created when producers try to write data into it. That means that if a producer tries to write an record to a topic named customers and that topic doesn’t exist yet – it will be automatically created to allow the writing. Instead of returning an error to the client.

AWS ElastiCache with a Bastion Host using Terraform

Mon, 09 Mar 2020 00:00:00 +0000

AWS ElastiCache is a fully managed service that allows users to easily and quickly use cache technologies like MemCached and Redis without the gory implementation details. But this doesn’t come for free. Developers often complain about the fact that the service is deployed in private subnets and due to that fact – they are not entitled to easily access for troubleshooting purposes.

A pattern to solve this problem is the usage of a bastion host, that sits between your machine and the private subnet to allow troubleshooting with ease. This post will show how to deploy a AWS ElastiCache service for Redis along with a bastion host using Terraform.

Multiple Columns with Redis Sorted Set

Tue, 03 Mar 2020 00:00:00 +0000

Recently I had to build an application that would store and order players in a Redis Sorted Set, but using multiple columns as criteria for the score, instead of just one. After trying to find a proper solution on the web and failing to do so; I decided to put my head to work and figure out an way. This post will show how did I accomplished that.

It turns out that my application has players with the following fields:

Confluent Go Client with Docker

Sat, 29 Feb 2020 00:00:00 +0000

If you are reading this blog post then there is a high chance that you’ve been looking for ways to make Confluent’s Go Client for Apache Kafka work with your Docker images but you’re struggling to. Am I right?

Don’t worry, you’ve came to the right place. After struggling with this myself I decided to share the solution that I’ve found with everybody else so we all can spend more time writing code than just wasting time with dependency plumbing.

Using Logitech Products with Fedora Linux

Thu, 06 Feb 2020 00:00:00 +0000

I am a huge fan of what Logitech creates for the computer industry and I have been using its products for quite some time now. However, for the last 5 years I took the [smart] decision of using Linux for desktop and by doing so – I realized that certain products seems only to work well with Mac/Windows, leaving no space for Linux.

In this post I will provide some tips about open-source projects that helps you to get your favorite Logitech products working smoothly with Linux, Fedora in particular.

Kafka Summit 2019 (San Francisco)

Fri, 04 Oct 2019 00:00:00 +0000

This week I had the honor of being one more time in the most exciting conference for Apache Kafka in the world, known as Kafka Summit. Only this time was different because I could contribute a lot for this conference.

My first contribution was building and recording a demo that was shown in the second day of the conference when Priya Shivakumar was talking about Confluent Cloud. I have received some good feedback about that demo, which of course made me feel really proud.

Kafka Summit San Francisco 2019

Tue, 01 Oct 2019 00:00:00 +0000

Session delivered at Kafka Summit San Francisco 2019.

Oracle Code One 2019

Mon, 23 Sep 2019 00:00:00 +0000

Last week I had the chance to attend one more time Oracle’s new developer’s conference know as Oracle Code One. It was so nice to catch up with great friends, plus being able to party with people from the Java community. They certainly know how to make things funny and entertaining.

Furthermore, I also had the chance to share a little about Apache Kafka in a talk that I delivered for a room full of developers interested in this technology.

Palestra "Abraçando a Anarquia: Design Patterns de Apache Kafka em Arquiteturas de Dados Modernas e Big Data" no QCon São Paulo

Sun, 15 Sep 2019 00:00:00 +0000

Esse ano eu tive a honra de poder palestrar pela primeira vez no QCon São Paulo , edição do evento que ocorreu em Maio de 2019.

Na ocasião, eu fiz parte da trilha de Big Data coordenada pela fera Fabiane Nardon, onde pude compartilhar um pouco da história do Apache Kafka , qual seu estado atual como tecnologia, e, quais casos de uso ele ajuda a resolver.

Vídeo :

https://www.youtube.com/watch?v=4ONf63koLtU

Slides :

https://speakerdeck.com/riferrei/abracando-a-anarquia-design-patterns-de-apache-kafka-em-arquiteturas-de-dados-modernas

My Talk @ Kafka Summit SFO 2019

Mon, 09 Sep 2019 00:00:00 +0000

We are less than one month away from the next edition of the world’s best conference about Apache Kafka known as Kafka Summit, and I would like to detail a bit what is going to be the focus of my talk Being an Apache Kafka Developer Hero in the World of Cloud.

https://kafka-summit.org/sessions/developer-hero-cloud/

As you can read in the description, this talk is all about Confluent Cloud, where I will be showing the first steps to start working with event streaming applications using this awesome Apache Kafka as-a-service product from Confluent. However, the interesting part here is how I am going to do that.

JEEConf, Kiev, Ukraine

Wed, 15 May 2019 00:00:00 +0000

This year I had the honor of speaking at JEEConf; one of the most important Java conferences in Europe hosted in the heart of Ukraine. The conference held two days full of content related to Java and related technologies.

I was really impressed with the number of smart people that I could shake hands and meet at the conference. One of the sessions that I presented there was Tips & Tricks about Apache Kafka in the Cloud for Java Developers, that aimed to show some of the details that developers building Java applications for Apache Kafka should know before venturing themselves in moving their workloads to Cloud.

LinkedIn and the Nightmare of Connection Requests

Mon, 07 Jan 2019 00:00:00 +0000

Is this just me or LinkedIn became this annoying social network where recruiters and people you never worked with keep poking you for new connections?

Like other professional social networks, LinkedIn was designed to connect people around the globe and empower them with the ability to get jobs, hire talents and be the backbone for professional communication. However, that concept has been exploited because there are people that leverage this concept for their own benefits.

#1 Apache Kafka Meetup in São Paulo/Brazil

Tue, 11 Dec 2018 00:00:00 +0000

During the week of Dec 2th I had the pleasure of visiting São Paulo/Brazil, a place that I once called home. It has been almost 5 years that I left that city to live abroad – and every time I go there its inevitable not to miss certain things.

I went down there to participate of the Google Cloud Summit event, and make sure that developers using GCP would be aware of Confluent’s Apache Kafka as a service know as Confluent Cloud. It was amazing to share this information with them, since most of them was working (or planning to work) with huge amounts of data in the Cloud and Kafka is certainly the right way to do it.

Confluent Cloud Tools is Alive

Fri, 09 Nov 2018 00:00:00 +0000

It gives me great pleasure to announce that Confluent Cloud Tools is officially released as a Confluent’s repository. The link to this repository is:

https://github.com/confluentinc/ccloud-tools

In a nutshell, the aim of this project is to allow developers to unfold the true agility that Confluent Cloud can provide –allowing them to focus on writing code instead of wasting time with manual and tedious configuration steps.

Very often developers use tools from Confluent such as Schema Registry, REST Proxy, Connect, KSQL and Control Center – along with their Kafka clusters. This may work fine when they are working On-Premise and making use of the integrated experience that Confluent Platform provides – whether if it is running Confluent Platform locally and managing things via the CLI or; if it is by using the built-in Docker containers.

ThinkPad Thunderbolt 3 Dock | Suspend Problem

Thu, 11 Oct 2018 00:00:00 +0000

As mentioned in this post; I have acquired a new laptop from Lenovo, the ThinkPad X1 Extreme. Since I will be working from home sometimes, I thought it would be a good idea to buy an dock station for it.

So I decided to buy the following dock station:

ThinkPad Thunderbolt 3 Dock

It is a nice dock station solution, especially because it connects everything to the laptop via Thunderbolt 3. However; since I am running Fedora in my laptop, things couldn’t be that easy right?

New Lenovo ThinkPad X1 Extreme

Tue, 09 Oct 2018 00:00:00 +0000

“It’s not a laptop. It’s a ThinkPad.” - I really like this slogan because it helps to explain why I took the decision to buy the new ThinkPad X1 Extreme from Lenovo, while there are some good options out there - presumably better ones. But let’s start from the beginning.

I have been working with IT for quite some time now, and for some reason I have never had a laptop of my own. Instead, I always used the laptops given by the companies I worked for. This is not a bad decision per-se, but in the long run you may find yourself disappointed with the whole keep-moving-things-around every time you change jobs.

Getting Myself Certified in AWS

Wed, 29 Aug 2018 00:00:00 +0000

August 2018 was a very productive month to me, where after some intense dog hours studying like crazy and practicing a lot - I was able to get certified in two of the most interesting AWS exams: Solutions Architect and Developer Associate.

That was quite of a challenge to me, because my Cloud background had been up to that point mainly focused on Oracle Cloud. It was interesting to see the differences between the two Cloud vendors, as well as seeing how AWS structures its services. Which BTW is amazing.

About

Mon, 01 Jan 0001 00:00:00 +0000