Learn Observability with the LGTM Stack - Pre-Requisites Skills & Setup Environment

#Introduction

Welcome to the Learn Observability with the LGTM Stack series! This series will guide you to mastery of the LGTM Stack — the combination of Loki for logs, Grafana for visualization, Tempo for traces, and Mimir for metrics — from conceptual foundations to production readiness. In total there are 36 episodes organized into six phases.

But before you touch a single LGTM component, there are foundational skills and software you must have. Why are these prerequisites important? Because observability was born to answer the complexity of distributed systems. If you don't yet understand how a single request spreads across many services, this entire series will feel like taking apart an engine without knowing what it does.

Episode 0 is your roadmap: we'll make sure your foundational skills are in place, set up Docker and local Kubernetes, verify the required CLIs, and check the minimum hardware. Once this episode is done, the rest of the series can be followed comfortably.

#Foundational Skills You Must Master

#Distributed Systems and Monitoring

You must understand that modern applications consist of many small services communicating with each other over HTTP/REST or gRPC. Understand the basics of TCP/IP, DNS, and ports, because every LGTM component communicates over the network. Also get comfortable reading YAML configuration files, because all of this stack's configuration is written in that format.

In addition, learn to distinguish the three types of telemetry data:

• Metrics: time-based numeric data, such as the number of requests per second.
• Logs: event records, usually one line per occurrence.
• Traces: the journey of a single request across many services.

The concept of time-series data is also a must — the LGTM Stack fundamentally stores and queries data that always relates to a time axis. PromQL, Mimir's main query language, will be covered in depth in episode 7, so for now it's enough to know it exists.

#Command Line and Containerization

You should be comfortable with a Linux/Unix terminal and able to install software via the CLI. Even more important: understand the basics of containerization with Docker, because almost the entire stack will run as containers.

docker --version
docker compose version

The output should show the Docker and Docker Compose plugin versions. If they're not installed, install Docker Engine and Docker Compose v2 first. For episodes 27-28 later, also prepare a local Kubernetes cluster such as Minikube, Kind, or K3s.

kubectl version --client

The docker compose version command will be used repeatedly in episode 4 when you run your first local stack.

#Software to Prepare

#LGTM Stack Core Components

A full installation of each component is only done in later episodes. For now, make sure the latest stable Grafana version can be downloaded and quickly run as a container so you have an idea of what to expect:

docker run -d --name grafana -p 3000:3000 grafana/grafana:latest

After that, open http://localhost:3000 in your browser and log in with admin / admin. Don't worry about configuration yet — in episode 4 we'll build the full stack, not just Grafana.

#Supporting Telemetry and Testing Tools

Besides the core components, prepare the following tools:

• OpenTelemetry Collector and Grafana Alloy — both will become the primary telemetry collectors; we'll cover them in episodes 11 and 16.
• Programming language SDK for instrumenting applications, for example Go, Python, Java, or Node.js. Pick one main language you're comfortable with.
• Text editor or IDE such as VS Code or IntelliJ.
• cURL or Postman for testing API endpoints.
• k6 or Apache Bench for load testing in episode 32.

To verify several supporting CLIs at once:

curl --version
go version
python3 --version
node --version

Feel free to skip the programming languages you don't use, but make sure curl and at least one language runtime are available. Hint: curl will be used very often to manually send telemetry to HTTP endpoints.

#Minimum Hardware Requirements

A complete LGTM Stack is fairly resource-hungry, especially if you run Kubernetes in parallel. Follow these minimum requirements:

• At least 8GB RAM, with 16GB or more recommended — Mimir and Tempo need plenty of memory while the ingester processes are running.
• At least 20GB of free storage for container images, volumes, and local data.
• At least a quad-core CPU — compiling sample applications and compressing logs both consume CPU.
• Stable network connectivity to pull images and use public registries.

If your machine doesn't meet the 8GB RAM requirement, run components one at a time and enable only certain features, for example Mimir in single-binary mode. Remember to do a quick check with free -h before starting:

free -h
df -h /

The values from free -h should show total memory above 8GB for this series to be comfortable to follow.

#Verifying Your Environment

Before moving on to episode 1, make sure everything is ready by running a final check:

docker ps
kubectl config current-context
free -h
df -h /

If docker ps runs without errors and kubectl config current-context returns a cluster context name (an empty result is fine if you haven't created a cluster yet), your environment is ready. Also make sure the trial Grafana container can be reached.

#Summary of Skills You Must Master

A summary of the prerequisites you've prepared in episode 0:

• Distributed systems concepts: HTTP/REST, TCP/IP, DNS, and ports.
• Understanding of telemetry: metrics, logs, traces, and time-series data.
• Docker and Docker Compose installed and verified.
• Local Kubernetes (Minikube, Kind, or K3s) as preparation for phase 6.
• Supporting CLIs: curl, kubectl, and one programming language runtime.
• Minimum hardware: 8GB+ RAM, 20GB storage, quad-core CPU.

If anything is missing, stop and complete it before continuing. A strong foundation will make the next 35 episodes feel much lighter.

#Closing

In episode 0 you've laid the groundwork for the entire series: understanding the foundational skills of distributed systems and telemetry, setting up Docker and local Kubernetes, verifying the supporting CLIs, and making sure the hardware is sufficient.

The key takeaways:

• Observability answers the complexity of distributed systems, not just a tool.
• The three types of telemetry must be understood from the start: metrics, logs, and traces.
• Docker Compose is the main way to run the stack locally.
• Local Kubernetes prepares you for phase 6.
• Make sure you have 8GB+ RAM, 20GB storage, and a quad-core CPU before continuing.

In the next episode 1 we'll discuss the history, background, and why you need observability — from the evolution of traditional monitoring toward cloud-native observability, the problems it solves, to a comparison of the LGTM Stack with ELK and commercial solutions. Make sure your environment is ready, because the Learn Observability with the LGTM Stack journey is just getting started!