Deploy OpenTelemetry on Google Cloud C4A Arm-based Axion VMs

content/learning-paths/servers-and-cloud-computing/opentelemetry/_index.md

@@ -0,0 +1,77 @@
+---
+title: Deploy OpenTelemetry on Google Cloud C4A Arm-based Axion VMs
+
+minutes_to_complete: 40
+
+who_is_this_for: This learning path is designed for DevOps engineers, platform engineers, and software developers who want to deploy and observe a cloud-native microservice on Arm64-based Google Cloud C4A Axion processors using OpenTelemetry, along with industry-standard observability tools.
+
+learning_objectives:
+  - Provision a SUSE Linux Enterprise Server (SLES) virtual machine on Google Cloud C4A Arm-based Axion processors
+  - Install and configure Docker and Docker Compose on an Arm64 environment
+  - Build and run an Arm-native Python Flask microservice in containers
+  - Instrument the microservice using OpenTelemetry SDK for distributed tracing and metrics
+  - Deploy and configure OpenTelemetry Collector for telemetry processing
+  - Integrate Prometheus for metrics collection and visualization
+  - Integrate Jaeger for distributed tracing and service visualization
+  - Expose and validate observability dashboards
+  - Generate traffic to observe telemetry data flow and performance behavior
+  - Understand observability best practices on Arm-based cloud infrastructure
+
+prerequisites:
+  - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
+  - Basic familiarity with Python and Flask
+  - Basic understanding of containers and Kubernetes concepts
+
+author: Pareena Verma
+
+##### Tags
+skilllevels: Introductory
+subjects: Performance and Architecture
+cloud_service_providers: Google Cloud
+
+armips:
+- Neoverse
+
+tools_software_languages:
+- Flask
+- Docker
+- Prometheus
+- Jaeger
+
+operatingsystems:
+- Linux
+
+# ================================================================================
+#       FIXED, DO NOT MODIFY
+# ================================================================================
+
+further_reading:
+  - resource:
+      title: Google Cloud documentation
+      link: https://cloud.google.com/docs
+      type: documentation
+
+  - resource:
+      title: OpenTelemetry documentation
+      link: https://opentelemetry.io/docs/
+      type: documentation
+
+  - resource:
+      title: Prometheus documentation
+      link: https://prometheus.io/docs/introduction/overview/
+      type: documentation
+
+  - resource:
+      title: Jaeger documentation
+      link: https://www.jaegertracing.io/docs/
+      type: documentation
+
+  - resource:
+      title: Docker documentation
+      link: https://docs.docker.com/
+      type: documentation
+
+weight: 1
+layout: "learningpathall"
+learning_path_main_page: yes
+---

content/learning-paths/servers-and-cloud-computing/opentelemetry/_next-steps.md

@@ -0,0 +1,8 @@
+---
+# ================================================================================
+#       FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21                  # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps"         # Always the same, html page title.
+layout: "learningpathall"   # All files under learning paths have this same wrapper for Hugo processing.
+---

content/learning-paths/servers-and-cloud-computing/opentelemetry/background.md

@@ -0,0 +1,37 @@
+---
+title: Get started with OpenTelemetry on Google Axion C4A 
+
+weight: 2
+
+layout: "learningpathall"
+---
+
+## Explore Axion C4A Arm instances in Google Cloud
+
+Google Axion C4A is a family of Arm-based virtual machines built on Google’s custom Axion CPU, which is based on Arm Neoverse-V2 cores. Designed for high-performance and energy-efficient computing, these virtual machines offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
+
+The C4A series provides a cost-effective alternative to x86 virtual machines while leveraging the scalability and performance benefits of the Arm architecture in Google Cloud.
+
+To learn more, see the Google blog [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu).
+
+
+## Explore OpenTelemetry on Google Axion C4A (Arm Neoverse V2)
+
+OpenTelemetry is an open-source observability framework that provides standardized APIs, SDKs, and tools for collecting telemetry data such as traces, metrics, and logs from cloud-native applications. It is a CNCF (Cloud Native Computing Foundation) project and is widely adopted for building vendor-neutral observability solutions.
+
+OpenTelemetry enables developers to instrument applications once and export telemetry data to multiple backend systems including Prometheus, Grafana, Jaeger, Zipkin, and cloud monitoring platforms.
+
+Running OpenTelemetry on Google Axion C4A Arm-based infrastructure allows you to achieve high-throughput telemetry processing with improved performance per watt and reduced infrastructure costs, making it ideal for modern distributed systems.
+
+Common use cases include application performance monitoring (APM), distributed tracing, infrastructure metrics collection, log aggregation, and monitoring microservices architectures.
+
+To learn more, visit the [OpenTelemetry website](https://opentelemetry.io/) and explore the [OpenTelemetry documentation](https://opentelemetry.io/docs/).
+
+## What you've accomplished and what's next
+
+In this section, you learned about:
+- Google Axion C4A Arm-based VMs and their performance characteristics  
+- OpenTelemetry observability framework and its role in modern cloud-native monitoring  
+- How Arm architecture enables cost-effective, high-performance telemetry processing  
+
+Next, you'll configure firewall rules and network access to allow external communication between your OpenTelemetry components and monitored services.

content/learning-paths/servers-and-cloud-computing/opentelemetry/firewall-setup.md

@@ -0,0 +1,63 @@
+---
+title: Create a firewall rule on GCP
+weight: 4
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Configure GCP firewall for OpenTelemetry
+
+To allow inbound traffic for the Flask application and observability components, you must create firewall rules in the Google Cloud Console.
+
+{{% notice Note %}} For more information about GCP setup, see [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).{{% /notice %}}
+
+## Required Ports
+
+| Service | Port | Purpose |
+|--------|------|---------|
+| Flask Application | 8080 | Application traffic |
+| Jaeger UI | 16686 | Trace visualization |
+| Prometheus UI | 9090 | Metrics dashboard |
+| OTLP gRPC | 4317 | Telemetry ingestion |
+| OTLP HTTP | 4318 | Telemetry ingestion |
+| Collector Metrics | 8889 | Prometheus scrape endpoint |
+
+## Create a Firewall Rule in GCP
+
+To expose the Flask application (port 8080), create a firewall rule.
+
+Navigate to the [Google Cloud Console](https://console.cloud.google.com/), go to **VPC Network > Firewall**, and select **Create firewall rule**.
+
+![Google Cloud Console VPC Network Firewall page showing existing firewall rules and Create Firewall Rule button alt-txt#center](images/firewall-rule1.png "Create a firewall rule")
+
+Next, create the firewall rule that exposes the TCP port 8080.
+Set the **Name** of the new rule to "allow-tcp-8080". Select your network that you intend to bind to your VM (default is "autoscaling-net", but your organization might have others).
+
+Set **Direction of traffic** to "Ingress". Set **Allow on match** to "Allow" and **Targets** to "Specified target tags".
+
+![Google Cloud Console firewall rule creation form showing name field, network selection, direction set to Ingress, and targets set to Specified target tags alt-txt#center](images/network-rule2.png "Creating the TCP/8080 firewall rule")
+
+Next, enter "allow-tcp-8080" in the **Target tags** text field. Set **Source IPv4 ranges** to "0.0.0.0/0".
+
+![Google Cloud Console firewall rule form showing target tags field with allow-tcp-8080 entered and source IPv4 ranges set to 0.0.0.0/0 alt-txt#center](images/network-rule3.png "Creating the TCP/8080 firewall rule")
+
+Finally, select **Specified protocols and ports** under the **Protocols and ports** section. Select the **TCP** checkbox, enter "8080" in the **Ports" text field, and select **Create**.
+
+![Google Cloud Console firewall rule form showing protocols and ports section with TCP selected and port 8080 specified alt-txt#center](images/network-port.png "Specifying the TCP port to expose")
+
+{{% notice Note %}}
+The above steps demonstrate how to open port **8080** for the Flask application.
+
+You can repeat the same workflow to create firewall rules for the following OpenTelemetry services:
+
+- **16686** → Jaeger UI  
+- **9090** → Prometheus UI  
+- **4317** → OTLP gRPC endpoint  
+- **4318** → OTLP HTTP endpoint  
+- **8889** → Collector metrics endpoint  
+
+Change the rule name and port number accordingly (for example: `allow-tcp-16686`, `allow-tcp-9090`, etc.).
+{{% /notice %}}
+
+You can now proceed to deploy and validate the OpenTelemetry stack.

content/learning-paths/servers-and-cloud-computing/opentelemetry/instance.md

@@ -0,0 +1,50 @@
+---
+title: Create a Google Axion C4A Arm virtual machine on GCP 
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Provision a Google Axion C4A Arm VM
+
+In this section you'll create a Google Axion C4A Arm-based virtual machine on Google Cloud Platform. You'll use the `c4a-standard-4` machine type, which provides 4 vCPUs and 16 GB of memory. This VM will host your OpenTelemetryapplication.
+
+{{% notice Note %}}
+For help with GCP setup, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
+{{% /notice %}}
+
+## Provision a Google Axion C4A Arm VM in Google Cloud Console
+
+To create a virtual machine based on the C4A instance type:
+- Navigate to the [Google Cloud Console](https://console.cloud.google.com/).
+- Go to **Compute Engine > VM Instances** and select **Create Instance**. 
+- Under **Machine configuration**:
+   - Populate fields such as **Instance name**, **Region**, and **Zone**.
+   - Set **Series** to `C4A`.
+   - Select `c4a-standard-4` for machine type.
+
+![Screenshot of the Google Cloud Console showing the Machine configuration section. The Series dropdown is set to C4A and the machine type c4a-standard-4 is selected alt-txt#center](images/gcp-vm.png "Configuring machine type to C4A in Google Cloud Console")
+
+
+- Under **OS and storage**, select **Change**, and then choose an Arm64-based operating system image.
+  - For this Learning Path, select **SUSE Linux Enterprise Server**.
+  - For the license type, choose **Pay as you go**.
+  - Increase **Size (GB)** from **10** to **100** to allocate sufficient disk space.
+  - Select **Choose** to apply the changes.
+- Under **Networking**, enable **Allow HTTP traffic** and **Allow HTTPS traffic** to simplify access for later Kubernetes testing.
+- Select **Create** to launch the virtual machine.
+
+After the instance starts, click **SSH** next to the VM in the instance list to open a browser-based terminal session.
+
+![Google Cloud Console VM instances page displaying running instance with green checkmark and SSH button in the Connect column alt-txt#center](images/gcp-pubip-ssh.png "Connecting to a running C4A VM using SSH")
+
+A new browser window opens with a terminal connected to your VM.
+
+![Browser-based SSH terminal window with black background showing Linux command prompt and Google Cloud branding at top alt-txt#center](images/gcp-shell.png "Terminal session connected to the VM")
+
+## What you've accomplished and what's next
+
+In this section, you provisioned a Google Axion C4A Arm VM and connected to it using SSH.
+
+Next, you'll need to install OpenTelemetry and the required dependencies on your VM.