Posted on

How to Operate Less and Innovate More Using Observability and AI

From software engineers to CEOs, everyone wants more time to think strategically instead of tactically executing tasks. While checking those tasks off your to-do list is important, and usually essential, are they the best use of your time? Humans prefer to do rather than to think, but those million-dollar ideas come from thinking. How can we fit more time into our day to make that happen? Unfortunately, we can’t. Time is finite, and we only have 24 hours in a day. But, what we can do is take some of those tasks off our plate. And I’m not talking about through a hiring spree, but rather investing in technology that can do the work for us. 

 This is especially true for DevOps practitioners and SRE teams who face enormous amounts of data and customer-facing issues. Today’s business leaders are pushing for their teams to spend more time innovating and less time fixing issues, yet some leaders haven’t invested in the technology to empower their teams to do so. By bringing AI-driven observability to DevOps, these issues can be addressed proactively through automation. As a result, teams can save hundreds of hours of work per year, empowering them to innovate more, operate less, and unlock their true potential. Let’s look at a few ways DevOps pros and SRE teams can leverage observability and AI to operate less and innovate more.

Posted on

Why Data-Driven Customer Success is Essential in Today’s COVID World

In today’s unprecedented economic downturn, it’s more difficult than ever to find and close new customers. The onus is now on maintaining existing customers as productive users of your product. By closely monitoring API metrics, Customer Success Management (CSM) teams can get an early warning on those that are at risk of churning, and rectify things before it’s too late.

Customer Acquisition Versus Customer Retention: At Least 5X Difference in Cost

According to different surveys, the average cost of acquiring a new customer is between 5X and 25X the cost of retaining an existing one. That was in the pre-COVID era. In today’s world, it’s probably more.

Posted on

Consul Deployment Patterns: A Brief Overview

If you've ever delved into a service mesh, key-value store, or service discovery solution in the cloud-native space, you have definitely come across Consul. Consul, developed by HashiCorp, is a multi-purpose solution which primarily provides the following features:

  • Service discovery and Service Mesh features with Kubernetes.
  • Secure communication and observability between the services.
  • Automate load-balancing.
  • Key-Value store.
  • Consul watches.

This blog post briefly explains the deployment patterns for Consul to use when making configuration changes that are stored in the Key-Value store. It will explain how to discover and synchronize with the services running out of the Kubernetes cluster. We will also see how to enable Service Mesh features with Consul. We broadly categorize Consul deployment patterns as in-cluster patterns (Consul deployed in a Kubernetes cluster) and hybrid patterns (Consul deployed outside a Kubernetes cluster).

Posted on

Rethinking Programming: Automated Observability

Introduction

Observability is the ability to understand the internal state of your system by looking at what is happening externally. In a software system, in order to acquire observability, we mainly implement the following aspects: logging, metrics, and tracing. Especially when we are moving away from monolithic software systems to microservices-based architectures, observability becomes a key aspect of the system design. Compared to monoliths, it’s much harder to troubleshoot issues and do performance tuning in microservices deployments. This is mainly due to the added complexity of working with a distributed system. Thus, your software system should understand these challenges, and be ready to handle any issues that may arise. Observability tools allow us to do this. 

In this article, we will focus on three observability tools:

Posted on

Provisioned Concurrency: The Silver Bullet to AWS Lambda Cold Starts

The year 2014 marked the start of the serverless era with Dr. Werner Vogels announcing AWS Lambda to an ecstatic crowd at AWS’ esteemed re:Invent. What was promised was a compute service abstracting away all the pains of cloud orchestration, thus leaving the user to only worry about the business logic they would run on these magic little worker nodes spun out of thin air and pure engineering.

Even though AWS Lambda was not the first FaaS service out there, with a startup called PiCloud being the first FaaS provider back in 2010, AWS was the first major cloud provider to jump into the race. In fact, it can be argued that AWS is actually the one that kick-started the serverless era, soon followed by Google Cloud Functions and Azure Functions by Microsoft. By 2017 the cloud wars intensified, with more and more providers descending upon the battlefield, all championing one promise, no more orchestration needed.

Posted on

Improving Kubernetes Observability and Monitoring

Get a closer look with visualizations, metrics, and SLAs.

Monitoring has always been a big part of solutions design. It is a continuous process of data collection about a system for the purpose of analyzing that system. Monitoring is usually done in an active way, with a tool pinging or probing a system in order to get responses. Those responses are then analyzed to better understand how the system is performing.

In recent years, as we shift towards a more open and manageable system in a cloud environment, monitoring becomes a mundane part of the process. This is where observability comes in. Despite the many debates about what observability really means, the reality is actually very simple: it is the process of making the data required for monitoring available from within the system.

Posted on

Observability and Beyond — Building Resilient Application Infrastructure

The ability to construct observable apps can't be overstated.

The Journey from Being Reactive to Being Proactive

Things were quite simple in the old days. Proactively monitoring applications or infrastructure was not the norm. If there was a failure, a user would pick up the phone to inform the help-desk that the app is broken.

Troubleshooting was all reactive and the only path to resolution was for someone to roll up their sleeves and go in and look at log files and manually fix errors by themselves.

Posted on

The Marvel of Observability

Marvel at this article!


You may also like: The Observability Pipeline
“[You’ve] been fighting with one arm behind your back. What happens when [you’re] finally set free?”
— Paraphrasing Carol Danvers, a.k.a. Captain Marvel

BOOK REVIEW: ''How to Architect and Build Highly Observable Systems'' by Baron Schwartz

Observability is a property of an application or system, not the actual act of analysis. The system is observable, practically and mathematically, if you can understand its inner workings and state by measuring its external behaviors. That means the system exposes telemetry, which is the data emitted from instrumentation that expresses those external behaviors — a feature ideally baked into your code upfront. Monitoring is the act of analyzing the telemetry to see whether the system is functioning correctly. Diagnostics is the process of determining what’s wrong with a system.

Posted on

Optimizing AWS Control Tower For Multiple AWS Accounts And Teams

You can see everything from up here!

One of the major benefits of optimizing Amazon Web Service is that it comes with an extensive set of tools for managing deployments and user identities. Most organizations can meticulously manage how their cloud environment is set up and how users can access different parts of that environment through AWS IAM.

However, there are times when even the most extensive IAM and other management tools just aren’t enough. For larger corporations or businesses who are scaling their cloud deployment on a higher level, setting up multiple AWS accounts—run by different teams—is often the solution.

Posted on

Continuous Modernization of Cloud Applications

Business applications — like businesses themselves — must constantly change and improve in response to new challenges and opportunities. In today's world, that evolution typically involves moving some or all of your IT environment into the cloud.

While the benefits can be tremendous, it's important to remember that cloud adoption and optimization is not a one-time, one-size-fits-all proposition. It's an ongoing process that demands a continuous commitment-as well as complete, full-stack observability to cope with the increasing complexity of your cloud systems and to make sure you're getting the results you expect.

Posted on

What Powers Observability With RUM Tools?

Real User Monitoring (RUM) is the ability to measure the performance of your website/web application as seen by your end users. Some of the measurements are well-supported, some are browser-specific, and a few standards allow observability by letting you decide the measurement parameters. In the plethora of tools, it is hard to understand the differences. With this post, I would like to provide you a firm foundation on the minimum supported provided by the RUM solution for some solid measurements.

In the old days of the wild-wild west, the performance measurements were instrumented using custom JavaScript code. The challenge was the measurement would begin only after the base HTML was downloaded and the JS code executed.

Posted on

Implementing Scalyr’s PowerQueries

Older log management solutions grew up with complex query languages, including huge libraries of “commands” to manipulate and visualize data. These complex languages make advanced tasks possible but are difficult and cumbersome even for everyday tasks. Only a handful of users ever really know how to use the language, and they typically have to undergo extensive training and certification in order to be productive.

With the benefit of experience, we were in a position to create a clean-sheet design that supports powerful data manipulation with a relatively simple language. The result is PowerQueries: a new set of commands for transforming and manipulating data on the fly. In this article, we’ll talk about how we were able to accomplish this without sacrificing performance.

Posted on

Introduction to Serverless Monitoring

Serverless models allow cloud providers to fully manage the provisioning and allocation of servers, as well as run applications in a stateless, ephemeral container when triggered by an event. This is incredibly useful for companies to be able to only charge customers for the time a function is running as well as for companies with unpredictable traffic because they don’t have to pay for idle resources. In our Introduction to Serverless Monitoring Refcard, you’ll get an introduction to serverless computing and monitoring, learn how serverless can play a role in IoT and machine learning, see how monitoring and observability differ, and more.
Posted on

Why You Can’t Afford to Ignore Distributed Tracing for Observability

Observability is a hot topic, but not a lot of people know what it truly means. Everyone reads about monitoring vs. observability these days, and I have had the chance to experience what I think is the main concept behind this movement.

First of all, monitoring is complicated. Dashboards don't scale because they usually reveal the information you need until only after an outage is experienced, and, at some point, looking for spikes in your graphs becomes a straining eye exercise. And that's not monitoring, it is just a "not very" smart way to understand how something isn't working. In other words, monitoring is just the tip of the iceberg where the solid foundation is the knowledge you have of your system.

Posted on

Debug Your Python Lambda Functions Locally

While developing your lambda functions, debugging may become a problem. As a person who benefits a lot from step-by-step debugging, I had difficulty debugging lambda functions. I got lost in the logs. Redeploying and trying again with different parameters over and over... then, I found the AWS Serverless Application Model (SAM) Command Line Interface (CLI). The AWS SAM CLI lets you debug your AWS Lambda functions in a good, old, step-by-step way.

If you don’t know AWS SAM CLI, you should definitely check it out here. Basically, using SAM CLI, you can locally run and test your Lambda functions in a local environment that simulates the AWS runtime environment. Without the burden of redeploying your application after each change, you can develop faster in an iterative way.