Search for a command to run...
I'm a seasoned Software Engineer with over half a decade of experience shaping the world of software development. My passion is anchored in writing code that is not just efficient, but also elegant and clean. An advocate for continuous improvement, I am forever on the hunt for the most cutting-edge developments in our dynamic industry.
No comments yet. Be the first to comment.
In this blog series, we'll explore microservices: from modeling to splitting the monolith, communication styles, CI/CD, and effective testing strategies. Join us for an enlightening journey!
I’ve often encountered the challenge of scaling a system. When you’re dealing with the ever-increasing demands on modern systems, it's important to ensure that your architecture can handle the lincreased load. In this blog post, I'll guide you throug...
In the past few months, I've had a lot of discussions with fellow tech leaders but also friends who work in tech. All of them encounter different challenges in their daily work. However, some stuff stands out and I have this idea to create a story wi...
19th of July, Friday morning's events serve as a stark reminder of the critical importance of best practices and quality standards. CrowdStrike, a leading cybersecurity company valued at around $80B, had a huge outage because of a failed global softw...
I've genuinely tried to extract the best from SCRUM, be it trying Scrum by the book, or mixing it with a sprinkle of Kanban. It is just not proving to me that it does what it says it does... I know this topic is widely debated, and many other tech le...
Achieving operational excellence is a goal many organizations strive for. This pursuit often leads to the adoption of methodologies designed to streamline processes, boost efficiency, and enhance productivity. Among these, Continuous Delivery and LEA...
This will be fun! Let's start with something I experienced not too long ago. Imagine you're working on a crucial project with tight deadlines. You're heavily relying on an online collaboration tool. Suddenly, there's a server outage. But instead of c...
In an increasingly connected world, systems can become very complex. To deal with this complexity, modern application development is moving towards a microservices architecture. However, along with these benefits come challenges. One of the most significant is maintaining observability in these complex systems. In this blog post we will cover the importance of observability and the considerations needed before starting a microservices project.
In a microservices architecture, multiple services work together to deliver a single application. These services may be distributed across different machines, networks, and even geographies. While this setup offers flexibility and scalability, it also introduces new challenges in understanding and monitoring the health and performance of the overall system. This is where observability comes into play.
Observability, in this context, refers to the ability to infer the internal state of a system from its external outputs. It's not just about monitoring for errors or anomalies but understanding the "why" behind them. The goal of observability is to get a comprehensive understanding of a system's behavior, which is very important for efficient debugging and ensuring optimal performance.
In a distributed system like microservices, a single request can pass through numerous services. Distributed tracing helps track these requests as they traverse through different services, capturing latency data and metadata along the way. This data is incredibly useful in identifying performance bottlenecks and understanding service dependencies.
Metrics provide quantitative data about programs' operation, while logs provide qualitative context. Both are invaluable for observability. Metrics might include data like response times, error rates, and resource utilization. Logs, on the other hand, provide detailed information about specific events and are often useful for debugging.
Once you're collecting traces, metrics, and logs, you'll need a way to review and analyze this information. Tools that provide alerting based on certain thresholds and visualization of data in a comprehensible manner can help quickly identify anomalies and comprehend system behavior.
While microservices provide many advantages, they are not always the right choice for every application. Here are some considerations before making the leap:
Microservices bring complexity, as you're trading monolithic simplicity for distributed systems challenges. Issues like network latency, fault tolerance, message serialization, and data consistency all come into play.
Microservices require an organization to work in a certain way. This architecture aligns well with small, cross-functional teams that take responsibility for specific services. If your organization is not ready for this, it may be better to stick with a monolithic architecture.
Microservices allow individual components to be scaled independently, which can provide efficiency and cost benefits. However, if your application doesn't require this level of scalability, the additional complexity introduced by microservices may not be worth it.
In a microservices architecture, each service should own its data and be the sole manipulator of its database. This can require a significant shift in how you manage and think about data, as it is very different from the traditional approach of a single, shared database.
Spring Cloud Sleuth is a distributed tracing solution for Spring Boot applications. It assigns a unique ID to every request that comes into your application and then passes this ID to all the downstream services it interacts with. This allows you to trace the path of a request through your entire system.
Zipkin is a distributed tracing system that helps gather timing data needed to troubleshoot latency problems in service architectures. It manages both the collection and lookup of this data. By correlating the gathered data, you can get a holistic view of your system's behavior.
Setting up Spring Cloud Sleuth is relatively straightforward. First, add the following dependency to your Maven pom.xml:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
With this, Sleuth will automatically add trace and span ids to all the logs written through the SLF4J logger( or any kind of logger). This means that by merely looking at your logs, you can understand the full path that each request takes through your system.
Zipkin provides a great UI for visualizing the traces gathered by Sleuth. It also stores the trace data, which allows you to search for traces and analyze performance over time.
Firstly, add the Zipkin and Sleuth starter dependency:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>
Then, you need to tell your application where the Zipkin server is. In your application.properties file, add the following:
spring.zipkin.baseUrl=http://localhost:9411/
The above assumes you're running Zipkin locally on its default port, 9411. If you're running it somewhere else, adjust the URL accordingly.
Additionally, Sleuth samples traces at a default rate of 10%. This means that only 10% of the traces are sent to Zipkin. For a debug or local environment, you might want to increase this sampling rate. You can set the sampling rate to 100% by adding the following line to your application.properties:
spring.sleuth.sampler.probability=1.0
With this setup, any requests made to or from your application will be traced and the traces will be sent to Zipkin.
You can quickly start a Zipkin server locally by running the following command in your terminal:
curl -SSL https://zipkin.io/quickstart.sh | bash -s
java -jar zipkin.jar
After starting Zipkin, you can navigate to http://localhost:9411 in your web browser to see Zipkin's UI. From here, you can search for traces by various criteria. Clicking on a trace will display the full details of that trace, including a visualization of the request's path through your system.
In conclusion, establishing observability in a microservice architecture is a crucial undertaking that enables comprehensive insight into system behavior, facilitates efficient debugging, and ensures optimal performance. This is achieved through the implementation of distributed tracing, collection of metrics and logs, as well as the utilization of alerting and visualization tools.
Distributed tracing is a powerful tool in a microservices architecture, and Spring Cloud Sleuth and Zipkin provide an easy way to get started with it in a Spring Boot application. By tracing requests, you can gain insight into your system's behavior, identify performance bottlenecks, and understand the interactions between your services.