Merge pull request #2930 from madeline-underwood/suse

Suse_reviewed

Author: jasonrandrews

content/learning-paths/servers-and-cloud-computing/timescaledb-on-gcp/_index.md

@@ -1,13 +1,9 @@
 ---
 title: Deploy a live sensor dashboard with TimescaleDB and Grafana on Google Cloud C4A
-
-draft: true
-cascade:
-    draft: true
 
 minutes_to_complete: 45
 
-who_is_this_for: This learning path is for DevOps engineers, database engineers, and software developers who want to deploy and operate TimescaleDB on SUSE Linux Enterprise Server (SLES) Arm64, ingest live time-series sensor data, and visualize it in Grafana.
+who_is_this_for: This is an introductory topic for DevOps engineers, database engineers, and software developers who want to deploy and operate TimescaleDB on SUSE Linux Enterprise Server (SLES) Arm64, ingest live time-series sensor data, and visualize it in Grafana.
 
 learning_objectives:
   - Install and configure TimescaleDB on Google Cloud C4A Axion processors by building from source for Arm64
@@ -70,5 +66,4 @@ layout: "learningpathall"
 learning_path_main_page: yes
 ---
 
-TimescaleDB is a high-performance, open-source time-series database built on PostgreSQL that provides powerful features for storing, querying, and analyzing time-series data efficiently. When you deploy TimescaleDB on Google Cloud C4A Axion Arm-based processors, you can achieve high-throughput time-series ingestion and query processing with optimized performance per watt and lower infrastructure costs. This Learning Path shows you how to build a complete time-series data pipeline with live sensor ingestion and real-time visualization using Grafana.
 

content/learning-paths/servers-and-cloud-computing/timescaledb-on-gcp/background.md

@@ -29,10 +29,10 @@ To learn more, visit the [TimescaleDB website](https://www.timescale.com/) and e
 
 ## What you've accomplished and what's next
 
-In this section, you learned about:
+In this section, you:
 
-* Google Axion C4A Arm-based VMs and their performance advantages for time-series workloads
-* TimescaleDB and its key features, including hypertables, continuous aggregates, and retention policies
-* How Arm architecture enables cost-efficient, high-throughput ingestion and query processing for time-series data
+- Explored Google Axion C4A Arm-based VMs and their performance advantages for time-series workloads
+- Reviewed TimescaleDB key features, including hypertables, continuous aggregates, and retention policies
+- Understood how Arm architecture enables cost-efficient, high-throughput ingestion and query processing
 
-Next, you'll create firewall rules to enable remote access to the Grafana dashboard that you'll build later in this Learning Path.
+Next, you'll create a firewall rule to enable remote access to the Grafana dashboard you'll build later in this Learning Path.

content/learning-paths/servers-and-cloud-computing/timescaledb-on-gcp/firewall-setup.md

@@ -9,31 +9,31 @@ layout: learningpathall
 Create a firewall rule in Google Cloud Console to expose TCP port 3000 for the TimescaleDB (Grafana) management interface.
 
 {{% notice Note %}}
-For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
+For help with GCP setup, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
 {{% /notice %}}
 
 ## Configure the firewall rule
 
 Navigate to the [Google Cloud Console](https://console.cloud.google.com/), go to **VPC Network > Firewall**, and select **Create firewall rule**.
 
-![Create a firewall rule](images/firewall-rule.png "Create a firewall rule")
+![Google Cloud Console VPC Network Firewall page showing the Create firewall rule button in the top menu bar alt-txt#center](images/firewall-rule.png "Create a firewall rule in Google Cloud Console")
 
 Next, create the firewall rule that exposes TCP port 3000.
 Set the **Name** of the new rule to "allow-tcp-3000". 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". Enter "allow-tcp-3000" in the **Target tags** text field. Set **Source IPv4 ranges** to "0.0.0.0/0".
 
-![Create a firewall rule](images/network-rule.png "Creating the TCP/3000 firewall rule")
+![Google Cloud Console Create firewall rule form with Name set to allow-tcp-3000, Direction of traffic set to Ingress, and Target tags field showing allow-tcp-3000 alt-txt#center](images/network-rule.png "Configuring the allow-tcp-3000 firewall rule")
 
 Finally, select **Specified protocols and ports** under the **Protocols and ports** section. Select the **TCP** checkbox, enter "3000" in the **Ports** text field, and select **Create**.
 
-![Specifying the TCP port to expose](images/network-port.png "Specifying the TCP port to expose")
+![Google Cloud Console Protocols and ports section with the TCP checkbox selected and port 3000 entered in the Ports text field alt-txt#center](images/network-port.png "Setting TCP port 3000 in the firewall rule")
 
 ## What you've accomplished and what's next
 
-You've successfully:
+In this section, you:
 
-* Created a firewall rule in Google Cloud to expose port 3000 for Grafana web interface access
-* Configured network ingress rules to allow remote connections to your dashboard
+- Created a firewall rule to expose TCP port 3000 for Grafana web interface access
+- Configured network ingress rules to allow remote connections from any source IP
 
 Next, you'll provision a Google Axion C4A Arm virtual machine and apply this firewall rule to enable external access to Grafana.

content/learning-paths/servers-and-cloud-computing/timescaledb-on-gcp/grafana-timescaledb-setup.md

@@ -1,18 +1,16 @@
 ---
-title: Grafana Setup & TimescaleDB Data Source Configuration
+title: Install Grafana and configure the TimescaleDB data source
 weight: 7
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Grafana Setup & TimescaleDB Data Source
+## Install and configure Grafana
 
 In this section, you install Grafana on a SUSE Arm64 virtual machine, access its web interface, and connect it to TimescaleDB. Grafana acts as the visualization layer that queries TimescaleDB and displays time-series data in dashboards.
 
-This setup enables real-time monitoring and analytics of sensor or application data stored in TimescaleDB.
-
-## Architecture (At This Stage)
+This setup enables real-time monitoring and analytics of sensor data stored in TimescaleDB.
 
 ```text
 Python Sensor Ingest Script
@@ -24,7 +22,7 @@ TimescaleDB (PostgreSQL)
 Grafana Dashboard
 ```
 
-## Install Grafana on SUSE (Arm64)
+## Install Grafana on SUSE
 
 Grafana is available via RPM packages and works natively on Arm64.
 
@@ -42,7 +40,7 @@ sudo systemctl start grafana-server
 sudo systemctl enable grafana-server
 ```
 
-**Verify status:**
+Verify the service is running:
 
 ```bash
 sudo systemctl status grafana-server
@@ -56,15 +54,15 @@ The output is similar to:
      Active: active (running) since Tue 2026-02-17 08:57:45 UTC; 1h 31min ago
 ````
 
-## Access Grafana Web UI
+## Access the Grafana web UI
 
 Open your browser and navigate to:
 
 ```bash
 http://<VM-PUBLIC-IP>:3000
 ```
 
-### Default Login Credentials
+### Default login credentials
 
 | Field    | Value |
 | -------- | ----- |
@@ -73,21 +71,17 @@ http://<VM-PUBLIC-IP>:3000
 
 You will be prompted to change the password on first login. Provide and save off a new password. Re-login if needed using the new password:
 
-![Grafana login page#center](images/grafana-login-page.webp "Grafana login page")
+![Grafana login page showing username and password fields with a Sign In button alt-txt#center](images/grafana-login-page.webp "Grafana login page")
 
 You will be presented with the main dashboard for Grafana:
 
-![Grafana dashboard#center](images/grafana-dashboard.webp "Grafana dashboard")
-
-## Add TimescaleDB as a Data Source
+![Grafana main dashboard showing the Home screen with sidebar navigation including Dashboards, Explore, and Connections menu items alt-txt#center](images/grafana-dashboard.webp "Grafana main dashboard")
 
-### Step 1: Open Data Sources
+## Add TimescaleDB as a data source
 
-From the Grafana sidebar:
+### Step 1: Open data sources
 
-```bash
-Connections → Data sources → Add data source
-```
+From the Grafana sidebar, navigate to **Connections** → **Data sources** → **Add data source**.
 
 ### Step 2: Choose PostgreSQL
 
@@ -96,7 +90,7 @@ Select PostgreSQL (TimescaleDB is PostgreSQL-compatible).
 ![Add PostgreSQL data source in Grafana#center](images/psql-data-source.png "Add PostgreSQL data source")
 
 
-### Step 3: Configure Connection Settings
+### Step 3: Configure connection settings
 
 Fill the form exactly as below:
 
@@ -108,24 +102,20 @@ Fill the form exactly as below:
 | Password      | `<postgres password saved>`    |
 | TLS/SSL Mode  | `disable`                      |
 
-![PostgreSQL data source connection settings#center](images/data-source-details.png "PostgreSQL data source settings")
+![PostgreSQL data source connection settings alt-txt#center](images/data-source-details.png "PostgreSQL data source settings")
 
-**Scroll down and click:**
-
-```text
-Save & Test
-```
+Scroll down and select **Save & Test**.
 
 You should see "Database connection OK."
 
-![Grafana PostgreSQL data source save and test success#center](images/data-source-save-test.png "Grafana PostgreSQL data source save and test")
+![Grafana PostgreSQL data source save and test success alt-txt#center](images/data-source-save-test.png "Grafana PostgreSQL data source save and test")
 
-## What You Have Accomplished
+## What you've accomplished and what's next
 
-- Installed Grafana on SUSE Arm64
-- Logged into Grafana UI
-- Connected Grafana to TimescaleDB successfully
+In this section, you:
 
-## What’s Next
+- Installed Grafana on SUSE Arm64 and started the service
+- Accessed the Grafana web UI and updated the default password
+- Connected Grafana to TimescaleDB as a PostgreSQL data source
 
-In the next section, you will create a live dashboard to visualize real-time sensor temperature data.
+In the next section, you'll create a live dashboard to visualize real-time sensor temperature data.

content/learning-paths/servers-and-cloud-computing/timescaledb-on-gcp/instance.md

@@ -18,26 +18,26 @@ For help with GCP setup, see the Learning Path [Getting started with Google Clou
 
 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.
+- 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#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**. Also, add the following tag "allow-tcp-3000" to enable remote grafana access.
-* Select **Create** to launch the virtual machine.
+- 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**. Also add the tag `allow-tcp-3000` to enable remote Grafana access.
+- 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.
+After the instance starts, select **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#center](images/gcp-pubip-ssh.png "Connecting to a running C4A VM using SSH")
+![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.
 
@@ -47,4 +47,4 @@ A new browser window opens with a terminal connected to your VM.
 
 In this section, you provisioned a Google Axion C4A Arm VM and connected to it using SSH.
 
-Next, you'll need to install TimescaleDB  and the required dependencies on your VM.
+Next, you'll install TimescaleDB and the required dependencies on your VM.

content/learning-paths/servers-and-cloud-computing/timescaledb-on-gcp/live-sensor-dashboard.md

@@ -1,16 +1,14 @@
 ---
-title: Live Sensor Temperature Dashboard
+title: Build a live sensor temperature dashboard
 weight: 8
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Create a Live Sensor Temperature Dashboard
+## Create a live sensor temperature dashboard
 
-In this section, you will create a **real-time Grafana dashboard** that visualizes **live temperature data** stored in **TimescaleDB**.
-
-This dashboard continuously updates and helps you monitor sensor temperature changes in near real time.
+In this section, you'll create a Grafana dashboard that visualizes live temperature data stored in TimescaleDB. The dashboard continuously updates to display sensor temperature changes in near real time.
 
 ## Prerequisites
 
@@ -42,22 +40,22 @@ Log in using your Grafana credentials.
 ## Create a New Dashboard
 
 - From the left sidebar, select **Dashboards**
-- Click **New dashboard**
-- Select Add a **new visualization**
+- Select **New dashboard**
+- Select **New visualization**
 
 You will be redirected to the Edit panel screen.
 
 ## Configure the Live Sensor Query
 
 In the Query section:
 
-- Data source: PostgreSQL / TimescaleDB
-- Query type: SQL
-- Format: Time series
+- **Data source:** PostgreSQL / TimescaleDB
+- **Query type:** SQL
+- **Format:** Time series
 
-![Grafana visualization configuration showing time series panel settings#center](images/data-source-visualization.png "Grafana visualization configuration")
+![Grafana time series panel editor showing the visualization configuration screen with the time series panel type selected and panel title field alt-txt#center](images/data-source-visualization.png "Grafana visualization configuration")
 
-Paste the following query after pressing the "Code" button on the right of the query editor:
+Paste the following query after selecting **Code** on the right of the query editor:
 
 ```sql
 SELECT
@@ -76,41 +74,31 @@ Apply the following settings in the right-hand panel:
 
   - Visualization Settings
 
-    - Visualization: Time series
-    - Panel title: Live Sensor Temperature
-    - Table view: Disabled
+    - **Visualization:** Time series
+    - **Panel title:** Live Sensor Temperature
+    - **Table view:** Disabled
 
   - Time & Refresh Settings
 
-    - Time range: Last 5 minutes
-    - Refresh interval: 5s
+    - **Time range:** Last 5 minutes
+    - **Refresh interval:** 5s
 
 These settings ensure the panel refreshes automatically with new data.
 
 ## Validate the Live Sensor Panel
 
 Once configured, the panel should display a continuously updating temperature graph.
 
-![Grafana dashboard showing Live Sensor Temperature time series panel alt-txt#center](images/live-sensor-temperature.webp "Live Sensor Temperature Panel")
+![Grafana live sensor temperature time series panel showing a continuous line graph of temperature readings from multiple sensors over the last 5 minutes alt-txt#center](images/live-sensor-temperature.webp "Live sensor temperature panel")
 
-## Save the Dashboard
+## Save the dashboard
 
-- Click Save dashboard (top-right corner)
+- Select **Save dashboard** (top-right corner)
 - Enter a name, for example: Live Sensor Monitoring Dashboard
-- Click Save
+- Select **Save**
 
 The dashboard is now active.
 
-## What you've accomplished and what's next
-
-You've successfully:
-
-- Built a complete time-series data pipeline on Google Cloud C4A Axion Arm-based processors
-- Installed and configured TimescaleDB by building from source for optimal Arm64 performance
-- Created a real-time sensor data ingestion pipeline using Python with hypertables and continuous aggregates
-- Configured retention policies and indexes for production-ready time-series storage
-- Installed Grafana and connected it to TimescaleDB as a data source
-- Built a live sensor dashboard that automatically refreshes to display real-time temperature data
-- Validated end-to-end data flow from ingestion through TimescaleDB to Grafana visualization
+## What you've accomplished
 
-You now have a production-ready time-series monitoring solution running natively on Arm infrastructure. This setup demonstrates how TimescaleDB and Grafana work together to provide comprehensive real-time monitoring for IoT and sensor workloads. You can extend this foundation by adding more sensors, creating additional dashboards, implementing alerting rules in Grafana, or optimizing TimescaleDB for your specific workload patterns.
+You've built a complete time-series monitoring pipeline on Google Cloud C4A Axion Arm-based processors. TimescaleDB is running natively on Arm64, ingesting live sensor data through Python, and serving queries to Grafana for real-time visualization. From here you can add more sensors, create additional dashboards, set up alerting rules in Grafana, or tune TimescaleDB for your specific workload.