diff --git a/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md b/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md index d33de9e4fa..bb07890fab 100644 --- a/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md @@ -6,15 +6,59 @@ minutes_to_complete: 15 who_is_this_for: This is an introductory guide for developers who want to measure and optimize the performance of applications running on Arm Neoverseā„¢-based servers. learning_objectives: - - Describe Arm's top-down profiling methodology. + - Identify the Arm top-down profiling methodology. - Use Streamline CLI tools to capture and analyze performance data from an application. prerequisites: - - An Arm Neoverse-based (N1, N2 or V1) computer running Linux. For your host OS, you can use Amazon Linux 2023 or newer, Debian 10 or newer, RHEL 8 or newer, or Ubuntu 20.04 or newer. + - An Arm Neoverse-based (N1, N2 or V1) computer running Amazon Linux 2023 or later, Debian 10 or later, RHEL 8 or later, or Ubuntu 20.04 or later + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:57:10Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c + summary_generated_at: '2026-11-19T15:57:10Z' + summary_source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c + faq_generated_at: '2026-11-19T15:57:10Z' + faq_source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c + summary: >- + You'll profile applications on Arm Neoverse Linux servers with Streamline CLI tools and + top-down analysis. First, you'll check hardware profiling support with Arm Sysreport and + learn how pipeline slots reveal performance bottlenecks. You'll then build with debug + information, capture samples with `sl-record`, analyze them with `sl-analyze`, and format + the report with `sl-format.py`. Finally, you'll use function metrics to prioritize + optimization. + faqs: + - question: How do I check whether my system supports hardware-assisted profiling? + answer: >- + Run Arm Sysreport and review its performance counter and Statistical Profiling Extension + (SPE) entries. You can see the available CPU counters and whether SPE is present. + - question: How do I include function names in the report? + answer: >- + Build your application with debug information before recording. You can then map sampled + instructions to functions in the analysis. + - question: Which Streamline CLI tools do I run, and in what order? + answer: >- + Use `sl-record` to capture samples, `sl-analyze` to create function metrics, and + `sl-format.py` to format the results. + - question: Which metrics help me identify a bottleneck? + answer: >- + Review `Retiring%`, `FE bound%`, `Bad spec%`, and `BE bound%` in the functions report. + You can use their relative values to decide which functions need closer inspection. + - question: What can I try if a hot function has instruction cache misses? + answer: >- + Consider profile-guided optimization to reduce less important code and leave more + instruction cache space for critical paths. Measure again to check the effect. +# END generated_summary_faq author: Julie Gaskin -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md index 8ed4a39c59..a8b903a3ea 100644 --- a/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md @@ -6,21 +6,63 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers deploying and optimizing Puppet workloads on Arm Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. learning_objectives: - - Provision an Arm-based SUSE SLES (SUSE Linux Enterprise Server) virtual machine (VM) on Google Cloud C4A with Axion processors - - Install Puppet on a SUSE Arm64 C4A instance - - Verify Puppet by applying a test manifest and confirming successful resource creation on Arm64 - - Benchmark Puppet by measuring catalog compile time, apply speed, and resource usage on Arm64 + - Provision an Arm-based SUSE SLES (SUSE Linux Enterprise Server) virtual machine (VM) on Google Cloud C4A with Axion processors. + - Install Puppet on a SUSE Arm64 C4A instance. + - Verify Puppet by applying a test manifest and confirming successful resource creation on Arm64. + - Benchmark Puppet by measuring catalog compile time, apply speed, and resource usage on Arm64. + +prerequisites: + - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled + - Basic familiarity with [Puppet](https://www.puppet.com/) + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:57:44Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde + summary_generated_at: '2026-11-19T15:57:44Z' + summary_source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde + faq_generated_at: '2026-11-19T15:57:44Z' + faq_source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde + summary: >- + You'll install and validate Puppet on a Google Axion C4A VM running SUSE Linux. After + provisioning a `c4a-standard-4` instance, you'll install dependencies and build Ruby before + installing Puppet. You'll then check Puppet and Facter versions, apply a test manifest, and + inspect the created resource. Finally, you'll run a standalone benchmark to measure local + catalog compilation and apply performance. + faqs: + - question: Which machine type and image should I select? + answer: >- + Choose `c4a-standard-4` and a SUSE Linux Enterprise Server arm64 image. + - question: Which command do I use to run the standalone Puppet benchmark? + answer: >- + Run `time puppet apply benchmark.pp --verbose` from `~/puppet-benchmark`. + You can review the catalog compilation and elapsed time in the output. + - question: How do I verify Puppet and Facter before applying a manifest? + answer: >- + Run `puppet --version` and `facter --version`. You should see a version from each + command. + - question: How do I verify that the test manifest worked? + answer: >- + Apply the manifest, then run `cat /tmp/puppet_test.txt` to inspect the file that it creates. + You can also review the Puppet resource change output. + - question: Where do I put the benchmark manifest? + answer: >- + Create `~/puppet-benchmark` and place the provided manifest there. You can then run the + benchmark and record its catalog compile time, apply speed, and resource usage. +# END generated_summary_faq author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false -prerequisites: - - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - - Basic familiarity with [Puppet](https://www.puppet.com/) - ##### Tags skilllevels: Introductory subjects: Performance and Architecture diff --git a/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md b/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md index cfb5f8217e..30a28c0d49 100644 --- a/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md @@ -3,7 +3,7 @@ title: Run a PyTorch LLM chatbot with KleidiAI on Arm minutes_to_complete: 30 -who_is_this_for: This is an introductory topic for software developers interested in running LLMs using PyTorch on Arm-based servers. +who_is_this_for: This is an introductory topic for software developers interested in running large language models (LLMs) using PyTorch on Arm-based servers. learning_objectives: - Download the Meta Llama 3.1 model from the Meta Hugging Face repository. @@ -13,14 +13,55 @@ learning_objectives: - Measure performance metrics of the LLM inference running on an Arm-based CPU. prerequisites: - - An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) with at least 16 CPUs from a cloud service provider or an on-premise Arm server. + - An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) with at least 16 CPUs from a cloud service provider, or an on-premise Arm server + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:58:37Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c + summary_generated_at: '2026-11-19T15:58:37Z' + summary_source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c + faq_generated_at: '2026-11-19T15:58:37Z' + faq_source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c + summary: >- + You'll run a PyTorch chatbot with KleidiAI INT4 kernels on an Arm server. First, you'll prepare + a Python environment and download Meta Llama 3.1 from Hugging Face. You'll quantize the model + to four bits and run CPU inference. Then, you'll start the Torchchat backend and Streamlit + frontend, test a prompt in the browser, and capture basic inference performance + measurements. + faqs: + - question: What Arm server do I need before starting? + answer: >- + Use an Arm server with Ubuntu 24.04 LTS, at least 16 cores, 64 GB of memory, and 50 GB + of storage. You can use the tested AWS Graviton4 `r8g.4xlarge` setup as reference. + - question: Which model do I download? + answer: >- + Download Meta Llama 3.1 from its Meta repository on Hugging Face. + - question: Which Python environment do I activate for the frontend? + answer: >- + Run `source torch_env/bin/activate` before you install the frontend dependencies. + - question: How do I resolve the httpx proxies error? + answer: >- + Install `httpx==0.27.2`, then restart the + frontend. + - question: How do I check that the chatbot works end to end? + answer: >- + Start the Torchchat backend and Streamlit frontend. Open the web interface, enter a + prompt, and check that you receive a model response. +# END generated_summary_faq author: - Nikhil Gupta - Pareena Verma - Nobel Chowdary Mandepudi -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md b/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md index 990b66796c..7abcb1f6d2 100644 --- a/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md @@ -7,11 +7,11 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers, data engineers, and platform engineers who want to build semantic search systems and chatbot retrieval pipelines on Arm64-based Google Cloud C4A Axion processors using the Qdrant vector database. learning_objectives: - - Deploy and run the Qdrant vector database on Google Cloud C4A Axion processors - - Generate vector embeddings using transformer models - - Store and index embeddings efficiently using Qdrant - - Perform semantic similarity search using vector queries - - Build a simple chatbot retrieval system powered by vector search + - Deploy and run the Qdrant vector database on Google Cloud C4A Axion processors. + - Generate vector embeddings using transformer models. + - Store and index embeddings efficiently using Qdrant. + - Perform semantic similarity search using vector queries. + - Build a simple chatbot retrieval system powered by vector search. prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled @@ -19,9 +19,50 @@ prerequisites: - Basic understanding of machine learning embeddings - Familiarity with Linux command-line operations +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:59:16Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b + summary_generated_at: '2026-11-19T15:59:16Z' + summary_source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b + faq_generated_at: '2026-11-19T15:59:16Z' + faq_source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b + summary: >- + You'll deploy Qdrant on a Google Axion C4A VM and use vector embeddings for semantic search. + You'll provision a SUSE Linux arm64 instance, prepare Qdrant, and generate embeddings from + sample text with Sentence Transformers. After storing the vectors in a Qdrant collection, + you'll run similarity queries and connect retrieval to a chatbot. You can then test whether + responses use relevant stored content. + faqs: + - question: What do I need before provisioning the virtual machine? + answer: >- + You need a Google Cloud account with billing enabled. + - question: Which C4A machine type should I choose? + answer: >- + Select `c4a-standard-4` in the Google Cloud console. + - question: Which operating system image should I use? + answer: >- + Choose a SUSE Linux Enterprise Server arm64 image for the C4A VM. + - question: What should I see after indexing embeddings? + answer: >- + You should have a Qdrant collection containing vectors generated from the sample text. + You can then query that collection for similar content. + - question: How do I check whether semantic search is working? + answer: >- + Run a similarity query and inspect the ranked matches. If the matches seem unrelated, check + that you inserted the embeddings. Ensure that you used the same Sentence Transformers model for + indexing and querying. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md b/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md index 42775ecb1f..42e9e41252 100644 --- a/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md @@ -8,19 +8,64 @@ minutes_to_complete: 60 who_is_this_for: This is an advanced topic for developers who want to build and benchmark QuantLib on Arm-based cloud instances. learning_objectives: - - Understand why QuantLib is a useful benchmark for Arm-based cloud systems - - Create and connect to an Arm64 Azure Cobalt virtual machine running Ubuntu - - Build QuantLib from source with benchmark support enabled - - Run QuantLib benchmark workloads with different sizes and thread counts - - Record and compare benchmark results in a repeatable way + - Identify why QuantLib is a useful benchmark for Arm-based cloud systems. + - Create and connect to an Arm64 Azure Cobalt virtual machine running Ubuntu. + - Build QuantLib from source with benchmark support enabled. + - Run QuantLib benchmark workloads with different sizes and thread counts. + - Record and compare benchmark results in a repeatable way. prerequisites: - An Azure account with permission to create virtual machines - Basic familiarity with the Linux command line and SSH - Basic experience building C++ software from source + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:59:43Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8 + summary_generated_at: '2026-11-19T15:59:43Z' + summary_source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8 + faq_generated_at: '2026-11-19T15:59:43Z' + faq_source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8 + summary: >- + You'll build and benchmark QuantLib on an Azure Cobalt-based Arm virtual machine. You'll provision an Ubuntu + virtual machine and build QuantLib from source with benchmark support and CPU-specific compiler flags. Then, you'll + run the benchmark executable. After a baseline run, you'll keep the workload size fixed and + change the number of worker processes. You'll then compare reported throughput and runtime + across runs to study scaling. + faqs: + - question: What Azure virtual machine configuration should I use? + answer: >- + Choose an Arm64 VM in a region that offers Azure Cobalt, such as West US 2. Use the `Standard_D4ps_v5` machine type and + Ubuntu Server 22.04 LTS. + - question: Where do I run the QuantLib benchmark? + answer: >- + Change to `~/QuantLib-$QL_VER/test-suite` and run `./quantlib-benchmark` after the + build. + - question: How do I vary workload size or worker count? + answer: >- + Use `--size` for the workload size and `--nProc` for the number of worker processes. + Keep `--size` fixed when you compare worker counts. + - question: How do I check that benchmark support was built? + answer: >- + Use the source `--enable-benchmark` configure option and `CFLAGS` and `CXXFLAGS` + settings. You'll then find a runnable `quantlib-benchmark` executable in the test + suite. + - question: What should I record from each benchmark run? + answer: >- + Record your `--size` and `--nProc` values alongside reported throughput in tasks per + second and runtime. You can compare your runs with the example results. +# END generated_summary_faq + author: Chris Moroney -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md index 1c4b46b4ea..bed320d510 100644 --- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md @@ -1,27 +1,66 @@ --- -title: Deploy RabbitMQ on Arm64 Cloud Platforms (Azure and GCP) +title: Deploy RabbitMQ on Arm64 on Microsoft Azure and Google Cloud minutes_to_complete: 30 who_is_this_for: This is an introductory topic for software engineers and platform engineers migrating messaging and event-driven workloads from x86_64 to Arm-based servers, specifically on Microsoft Azure Cobalt 100 Arm processors and Google Cloud C4A virtual machines powered by Axion processors. learning_objectives: - - Provision Arm-based Linux virtual machines on Google Cloud (C4A with Axion processors) and Microsoft Azure (Cobalt 100) - - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors) - - Install and configure RabbitMQ on Arm64 Linux (SUSE SLES on GCP and Ubuntu Pro 24.04 on Azure) - - Build and configure required Erlang versions for RabbitMQ on Arm64 - - Validate RabbitMQ deployments using baseline messaging and connectivity tests - - Implement practical RabbitMQ use cases such as event-driven processing and notification pipelines on Arm-based infrastructure + - Provision Arm-based Linux virtual machines (VMs) on Google Cloud and Microsoft Azure. + - Provision an Arm-based SUSE SLES VM on Google Cloud. + - Install and configure RabbitMQ on SUSE SLES on Google Cloud and Ubuntu Pro 24.04 on Azure. + - Build and configure required Erlang versions for RabbitMQ on Arm64. + - Validate RabbitMQ deployments using baseline messaging and connectivity tests. + - Implement practical RabbitMQ use cases such as event-driven processing and notification pipelines. prerequisites: - - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100-based instances (Dpsv6). + - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100-based instances (Dpsv6) - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - - Basic understanding of message queues and messaging concepts (publishers, consumers) + - Basic understanding of message queues and messaging concepts such as publishers and consumers - Familiarity with Linux command-line operations +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:00:22Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 952b6e5049d77bc49e9d51ffd3726f0a651623812d458923807ab59885e779af + summary_generated_at: '2026-11-19T16:00:22Z' + summary_source_hash: 952b6e5049d77bc49e9d51ffd3726f0a651623812d458923807ab59885e779af + faq_generated_at: '2026-11-19T16:00:22Z' + faq_source_hash: 952b6e5049d77bc49e9d51ffd3726f0a651623812d458923807ab59885e779af + summary: >- + You'll deploy and verify RabbitMQ on Arm-based Azure and Google Cloud VMs. First, you'll install + Erlang and RabbitMQ on an Azure Cobalt VM, enable the management plugin, and check the + service and versions. You'll then provision a Google Axion C4A VM, install RabbitMQ, and + configure a VPC firewall rule for management access. Finally, you'll check broker + connectivity and the management interface. + faqs: + - question: Which Azure virtual machine size should I use? + answer: >- + Select a Dpsv6 series VM backed by Azure Cobalt 100. + - question: Which image should I use for the Azure virtual machine? + answer: >- + Use Ubuntu Pro 24.04 for Arm64. + - question: How do I verify RabbitMQ on the Azure VM? + answer: >- + Run `sudo systemctl status rabbitmq` and check for `active (running)`. + - question: How do I check the Erlang version on Azure? + answer: >- + Run `erl -eval` and check that the output reports Erlang/OTP 26. + - question: How do I fix not being able to open the management interface on the Google Cloud VM? + answer: >- + Check that your VPC firewall rule allows inbound TCP port `15672` and that its target + tag is applied to the VM. You can compare the rule with the `allow-tcp-15672` example. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/rag/_index.md b/content/learning-paths/servers-and-cloud-computing/rag/_index.md index bc4ecb7405..b689ce0e58 100644 --- a/content/learning-paths/servers-and-cloud-computing/rag/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/rag/_index.md @@ -13,15 +13,57 @@ learning_objectives: - Monitor and analyze inference performance metrics. prerequisites: - - A Google Cloud Axion (or other Arm) compute instance with at least 16 cores, 8GB of RAM, and 32GB disk space. - - Basic understanding of Python and ML concepts. - - Familiarity with REST APIs and web services. - - Basic knowledge of vector databases. - - Understanding of LLM fundamentals. + - A Google Cloud Axion (or other Arm) compute instance with at least 16 cores, 8GB of RAM, and 32GB disk space + - Basic understanding of Python and ML concepts + - Familiarity with REST APIs and web services + - Basic knowledge of vector databases + - Understanding of LLM fundamentals + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:01:02Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 1f6f741dee3f86b86de1acaf18a51e807b000f19d8da40b0a4dfdb6d356e4d54 + summary_generated_at: '2026-11-19T16:01:02Z' + summary_source_hash: 1f6f741dee3f86b86de1acaf18a51e807b000f19d8da40b0a4dfdb6d356e4d54 + faq_generated_at: '2026-11-19T16:01:02Z' + faq_source_hash: 1f6f741dee3f86b86de1acaf18a51e807b000f19d8da40b0a4dfdb6d356e4d54 + summary: >- + You'll build a retrieval augmented chatbot with KleidiAI on an Arm-based Google Axion server. + You'll prepare a llama-cpp-python backend with FAISS retrieval and expose its API through + Flask. Then, you'll start a Streamlit frontend, upload PDF files, and ask questions that use + retrieved context. Finally, you'll open the app in a browser and verify that the backend and + frontend communicate. + faqs: + - question: How do I check whether backend.py is running? + answer: >- + Start `backend.py` and check that Flask listens on port `5000` without errors. You can + then use the frontend to test a response. + - question: What should I check when Streamlit loads but chat requests fail? + answer: >- + Check that the backend is running and that the `API_URL` in `frontend.py` points to its + address and port. Restart Streamlit after changing the URL. + - question: How do I open the app from outside the virtual machine? + answer: >- + Open `http://[your instance ip]:8501` in your browser. If you can't connect, allow inbound TCP port `8501` from your IP address. + - question: Where do I upload content for retrieval? + answer: >- + Upload PDF files through the Streamlit interface. You can then ask questions about the + content indexed in FAISS. + - question: Do I run the backend and frontend in separate terminals? + answer: >- + Yes. Activate the virtual environment and run the Flask backend in one terminal. Open + another terminal, activate the environment, and start the Streamlit frontend. +# END generated_summary_faq author: Nobel Chowdary Mandepudi -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/ran/_index.md b/content/learning-paths/servers-and-cloud-computing/ran/_index.md index b67014d269..e7f001915d 100644 --- a/content/learning-paths/servers-and-cloud-computing/ran/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/ran/_index.md @@ -1,5 +1,5 @@ --- -title: Get started with the Arm 5G RAN Acceleration Library (ArmRAL) +title: Build and run the Arm 5G RAN Acceleration Library minutes_to_complete: 15 @@ -7,16 +7,56 @@ who_is_this_for: This is an introductory topic for software developers new to th Arm RAN Acceleration Library (ArmRAL). learning_objectives: -- Build and install the Arm RAN Acceleration Library -- Test the capabilities of your platform +- Build and install the Arm RAN Acceleration Library. +- Test the capabilities of your platform. prerequisites: -- An Arm computer running Linux. Cloud instances can be used, refer to the list of - [Arm cloud service providers](/learning-paths/servers-and-cloud-computing/csp/). +- An Arm computer running Linux, or a [cloud instance](/learning-paths/servers-and-cloud-computing/csp/) + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:01:59Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 3496670e85ea5fd32e280256d6bb5b45a5fd873dba57aacb053ae69d293afd2f + summary_generated_at: '2026-11-19T16:01:59Z' + summary_source_hash: 3496670e85ea5fd32e280256d6bb5b45a5fd873dba57aacb053ae69d293afd2f + faq_generated_at: '2026-11-19T16:01:59Z' + faq_source_hash: 3496670e85ea5fd32e280256d6bb5b45a5fd873dba57aacb053ae69d293afd2f + summary: >- + You'll build and test the Arm RAN Acceleration Library on an Arm-based Linux system. First, you'll + prepare the development environment, obtain the source, and compile the library with GCC. + You'll then run `make check` to exercise its test suite and inspect the results. Finally, you'll end with a working ArmRAL build to explore telecommunications functions that are used in radio access + networks. + faqs: + - question: Which compiler and build command do I use? + answer: >- + Use GCC on an Arm-based Linux system to build the source. You can + then run `make check` in the build directory. + - question: Can I use an Arm cloud virtual machine instead of local hardware? + answer: >- + Yes, you can follow the build on an Arm-based cloud virtual machine running Linux. + - question: How do I verify the ArmRAL build? + answer: >- + Run `make check` after building. You should see the test suite complete without + failures. + - question: How do I choose the ArmRAL build target for my CPU? + answer: >- + Run `cat /proc/cpuinfo` and check the flags for `asimd`, `sve`, or `sve2`. + Set `ARMRAL_ARCH` to `NEON`, `SVE`, or `SVE2` to match a feature that your CPU supports. + - question: What should I do if the check fails? + answer: >- + Review the failing test in the `make check` output. Check that you built with the + required compiler and dependencies on your Arm Linux system. +# END generated_summary_faq author: Ronan Synnott -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md b/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md index e5c8c9a278..069adacddc 100644 --- a/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md @@ -1,24 +1,65 @@ --- -title: Scale AI workloads with Ray on Google Cloud C4A Axion VM -description: Deploy and run distributed AI workloads using Ray on Google Cloud Axion C4A Arm-based VMs, covering parallel tasks, hyperparameter tuning, and model serving with Ray Core, Train, Tune, and Serve. +title: Scale AI workloads with Ray on an Arm-based Google Cloud C4A VM +description: Deploy and run distributed AI workloads using Ray on Google Cloud C4A Arm-based VMs powered by Axion, covering parallel tasks, hyperparameter tuning, and model serving with Ray Core, Train, Tune, and Serve. minutes_to_complete: 30 -who_is_this_for: This is an introductory topic for DevOps engineers, ML engineers, and software developers who want to deploy and run distributed workloads using Ray on SUSE Linux Enterprise Server (SLES) Arm64, execute parallel tasks, perform hyperparameter tuning, and serve models at scale. +who_is_this_for: This is an introductory topic for DevOps engineers, ML engineers, and software developers who want to deploy and run distributed workloads using Ray on SUSE Linux Enterprise Server (SLES) Arm64, run parallel tasks, perform hyperparameter tuning, and serve models at scale. learning_objectives: - - Install and configure Ray on Google Cloud C4A Axion processors for Arm64 - - Run distributed tasks and parallel workloads using Ray Core - - Perform distributed training and hyperparameter tuning using Ray Train and Ray Tune - - Deploy scalable APIs using Ray Serve and validate end-to-end execution + - Install and configure Ray on Google Cloud C4A Axion processors for Arm64. + - Run distributed tasks and parallel workloads using Ray Core. + - Perform distributed training and hyperparameter tuning using Ray Train and Ray Tune. + - Deploy scalable APIs using Ray Serve and validate end-to-end execution. prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - Basic familiarity with Python and distributed systems concepts +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:02:33Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: c4924540b24617061378fbf4f2037973c30cd2b5a3dec1de80119721fa618d6a + summary_generated_at: '2026-11-19T16:02:33Z' + summary_source_hash: c4924540b24617061378fbf4f2037973c30cd2b5a3dec1de80119721fa618d6a + faq_generated_at: '2026-11-19T16:02:33Z' + faq_source_hash: c4924540b24617061378fbf4f2037973c30cd2b5a3dec1de80119721fa618d6a + summary: >- + You'll run Ray on a single Google Cloud C4A VM with SUSE Linux. You'll provision a + `c4a-standard-4` instance and configure firewall access for the Ray Dashboard and Ray Serve. + After installing Ray, you'll initialize the runtime and run `ray_test.py` to verify parallel + tasks. You'll then explore distributed training and hyperparameter tuning, using task output + and the Ray Dashboard to inspect execution. + faqs: + - question: Which Google Cloud machine type should I select? + answer: >- + Choose `c4a-standard-4`, which provides four vCPUs and 16 GB of memory. + - question: How do I verify that Ray runs on the virtual machine? + answer: >- + Run `ray_test.py`. You should see `Results:` followed by squared values from 0 through + 81. + - question: Which ports do I need for Ray Dashboard and Ray Serve? + answer: >- + Allow TCP port `8265` for the Dashboard and TCP port `8000` for Serve. Check that the + firewall rule applies to your VM. Use its external IP to connect. + - question: Do I need a multi-node cluster? + answer: >- + No. You can complete these steps on one C4A VM with a single-node Ray runtime. + - question: What should I check if I can't connect to the Ray cluster? + answer: >- + Check whether you started the Ray head node with `ray start --head`, then run `ray + status` to inspect the cluster before retrying your script. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md b/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md index beadbe4f4b..acc16f0c71 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md @@ -7,20 +7,63 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers, DevOps engineers, and platform engineers who want to build real-time messaging systems and event-driven applications using Redis on Arm-based cloud environments. learning_objectives: - - Install and configure Redis on Azure Cobalt 100 Arm64 virtual machines - - Implement real-time messaging using Redis Pub/Sub - - Build event-driven pipelines using Redis Streams and consumer groups - - Benchmark Redis performance and validate throughput and latency on Arm + - Install and configure Redis on Arm64 virtual machines powered by Azure Cobalt 100. + - Implement real-time messaging using Redis Pub/Sub. + - Build event-driven pipelines using Redis Streams and consumer groups. + - Benchmark Redis performance and validate throughput and latency on Arm. prerequisites: - - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 100 based instances (Dpsv6) + - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 100-based instances (Dpsv6) - Basic knowledge of Linux command-line operations - Familiarity with SSH and remote server access - Basic understanding of databases, caching, and messaging systems +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:03:25Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 06b2317b6273703a23729a1c59e8c11450d494f7634699020778ff53a573edad + summary_generated_at: '2026-11-19T16:03:25Z' + summary_source_hash: 06b2317b6273703a23729a1c59e8c11450d494f7634699020778ff53a573edad + faq_generated_at: '2026-11-19T16:03:25Z' + faq_source_hash: 06b2317b6273703a23729a1c59e8c11450d494f7634699020778ff53a573edad + summary: >- + You'll deploy Redis on an Azure Cobalt VM and use it for messaging and event processing. First, you'll + provision a Dpsv6 instance, install Redis, and check server connectivity. You'll then publish + and subscribe to messages, create Streams and consumer groups, and acknowledge processed + events. Finally, you'll use Python workload scripts and `redis-benchmark` to measure + throughput and latency on the Arm-based VM. + faqs: + - question: How do I verify that the Redis server started? + answer: >- + Run `src/redis-cli` after starting Redis, then enter `PING` at the CLI prompt. You + should receive `PONG` before testing messaging. + - question: Do I need multiple terminals for Pub/Sub and Streams? + answer: >- + Yes. Keep the Redis server running in one terminal and use other terminals for the + publisher and consumers. + - question: What should I see when Pub/Sub works? + answer: >- + Subscribe to a channel, then publish a message from another terminal. You should see + that message arrive in the subscriber terminal. + - question: When should I use Pub/Sub or Streams? + answer: >- + Use Pub/Sub for immediate message delivery to active subscribers. Use Streams and + consumer groups when you need to distribute and acknowledge queued work. + - question: How do I run a Redis benchmark? + answer: >- + Run `src/redis-benchmark -q -n 100000 -c 50` from the Redis source directory. You can + review the reported request rates for each operation. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md b/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md index 0fde9d5d33..79280f34ab 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md @@ -3,21 +3,61 @@ title: Deploy Redis for data searching on Google Cloud C4A minutes_to_complete: 30 -who_is_this_for: This is an introductory topic for developers deploying and optimizing Redis-based data searching workloads on Linux/Arm64 environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. +who_is_this_for: This is an introductory topic for developers deploying and optimizing Redis-based data searching workloads on Linux/Arm64 environments, specifically using Google Cloud C4A virtual machines (VMs) powered by Axion processors. learning_objectives: - - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors) - - Install Redis on a SUSE Arm64 (C4A) instance - - Verify Redis functionality by running the server and performing baseline data insertion and retrieval tests on the Arm64 VM - - Measure Redis SET (write) and GET (read) performance using the official redis-benchmark tool to evaluate throughput and latency on Arm64 (AArch64) + - Provision an Arm-based SUSE SLES C4A virtual machine on Google Cloud. + - Install Redis on a SUSE Arm64 instance. + - Verify Redis functionality by running the server and performing baseline data insertion and retrieval tests on the Arm64 VM. + - Measure Redis SET (write) and GET (read) performance using the official redis-benchmark tool to evaluate throughput and latency on Arm64 (AArch64). prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - - Basic familiarity with [Redis](https://redis.io/) + - Basic familiarity with [Redis](https://redis.io/) + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:03:54Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 3932c64a3ffa2252da47514025674e19c9f77e6543acb992654d62828e7fe8fd + summary_generated_at: '2026-11-19T16:03:54Z' + summary_source_hash: 3932c64a3ffa2252da47514025674e19c9f77e6543acb992654d62828e7fe8fd + faq_generated_at: '2026-11-19T16:03:54Z' + faq_source_hash: 3932c64a3ffa2252da47514025674e19c9f77e6543acb992654d62828e7fe8fd + summary: >- + You'll install Redis on a Google Axion C4A VM and test data search on SUSE Linux. First, you'll + provision a `c4a-standard-4` instance, build Redis from source, and verify the server with + `redis-cli ping`. You'll then insert sample data, retrieve keys, and compare pattern searches + with `SCAN`. Finally, you'll run SET and GET benchmarks to inspect request rates and latency + on Arm. + faqs: + - question: What virtual machine type and image should I use? + answer: >- + Select `c4a-standard-4` and a SUSE arm64 image. + - question: What do I install before building Redis? + answer: >- + Use `zypper` to install `gcc`, `gcc-c++`, and `make`, as well as `tcl`, `openssl-devel`, and `wget` + after refreshing repositories. + - question: Which Redis version do I build? + answer: >- + Download and build Redis `8.2.2` from its official GitHub source archive. + - question: How do I check that Redis is running? + answer: >- + Start Redis with `redis-server &`, then run `redis-cli ping`. You should receive `PONG`. + - question: How do I compare write and read performance? + answer: >- + Run `redis-benchmark -t set -n 100000 -c 50` for SET and `redis-benchmark -t get -n + 100000 -c 50` for GET. You can compare their throughput and latency output. +# END generated_summary_faq author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis/_index.md b/content/learning-paths/servers-and-cloud-computing/redis/_index.md index 6d59d83f0c..a6d3e71c77 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis/_index.md @@ -6,17 +6,54 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers who want to deploy Redis on Arm based virtual machines. learning_objectives: - - Understand Redis deployment configurations - - Install and run Redis in a single-node Arm based instance + - Identify Redis deployment configurations. + - Install and run Redis in a single-node Arm based instance. prerequisites: - - An Arm based instance from a cloud service provider, or an on-premise Arm server. - - If you do not have an Arm node, the next section discusses some options. + - An Arm based instance from a cloud service provider, or an on-premise Arm server + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:03:01Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: e8e8c501fb3a45836ddd838ba397139f4a050e39d750dda05e2baa9333c6a782 + summary_generated_at: '2026-11-19T16:03:01Z' + summary_source_hash: e8e8c501fb3a45836ddd838ba397139f4a050e39d750dda05e2baa9333c6a782 + faq_generated_at: '2026-11-19T16:03:01Z' + faq_source_hash: e8e8c501fb3a45836ddd838ba397139f4a050e39d750dda05e2baa9333c6a782 + summary: >- + You'll deploy a single-node Redis server on an Arm-based Linux instance. First, you'll install Redis, + start the service, and confirm a local connection. You'll then set the `bind` directive in `redis.conf`, and use + `redis-cli` to check connectivity from another machine. + faqs: + - question: What address does Redis listen on by default? + answer: >- + By default, Redis listens on `127.0.0.1:6379`. + - question: Why can't I connect from another machine? + answer: >- + Redis binds to `127.0.0.1` by default. Set the `bind` directive in `redis.conf` to + `0.0.0.0`, then restart Redis. + - question: How do I test a remote connection? + answer: >- + Run `redis-cli -h -p 6379` from your client, then send `PING`. You + should receive `PONG`. + - question: Which port does this deployment use? + answer: >- + Use the Redis default TCP port, `6379`, for local and remote connection checks. + - question: How do I check that Redis stores and retrieves data? + answer: >- + In `redis-cli`, run `SET name test`, then `GET name`. You should receive `"test"`. +# END generated_summary_faq author: Elham Harirpoush -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md b/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md index 2ddf11da19..62a021d6cc 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md +++ b/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md @@ -30,7 +30,7 @@ To connect to the remote Redis server, you need to use Redis Client (`redis-cli` ### Connect to the Redis server from local machine -Execute the steps below to connect to the remote Redis server from your local machine. +Run the following steps to connect to the remote Redis server from your local machine. 1. Install redis-tools to interact with redis-server: ```console diff --git a/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md b/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md index 05fbf8d9b0..02cd4b72f2 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md @@ -3,11 +3,11 @@ title: Deploy Redis as a cache for MySQL and PostgreSQL on Arm servers minutes_to_complete: 90 -who_is_this_for: This is an advanced topic for developers who want to deploy Redis as a cache on Arm based virtual machines. +who_is_this_for: This is an advanced topic for developers who want to deploy Redis as a cache on Arm-based virtual machines (VMs). learning_objectives: - - Deploy Redis as a cache for MySQL on AWS, Azure and GCP Arm based instance - - Deploy Redis as a cache for Postgres on AWS, Azure and GCP Arm based instance + - Deploy Redis as a cache for MySQL on AWS, Azure and GCP Arm based instance. + - Deploy Redis as a cache for Postgres on AWS, Azure and GCP Arm based instance. prerequisites: - An Amazon Web Services (AWS) [account](https://aws.amazon.com/) @@ -15,9 +15,52 @@ prerequisites: - A Google Cloud [account](https://console.cloud.google.com/) - A machine with [Terraform](/install-guides/terraform/), [AWS CLI](/install-guides/aws-cli), [Google Cloud CLI](/install-guides/gcloud), [Azure CLI](/install-guides/azure-cli), [AWS IAM authenticator](https://docs.aws.amazon.com/eks/latest/userguide/install-aws-iam-authenticator.html), and [Ansible](/install-guides/ansible/) installed +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:04:26Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: ea2a08e991d4de8363d55711b8f0984b977c395cee4840e31524cad2973e613f + summary_generated_at: '2026-11-19T16:04:26Z' + summary_source_hash: ea2a08e991d4de8363d55711b8f0984b977c395cee4840e31524cad2973e613f + faq_generated_at: '2026-11-19T16:04:26Z' + faq_source_hash: ea2a08e991d4de8363d55711b8f0984b977c395cee4840e31524cad2973e613f + summary: >- + You'll deploy Redis as a cache for MySQL or PostgreSQL on Arm-based AWS, Microsoft Azure, and Google Cloud VMs. You'll use + Terraform to provision infrastructure and Ansible to configure Redis with the selected + database. Finally, you'll run the example application for your provider and database pairing + to check cached data access. + faqs: + - question: How do I confirm that a query result came from Redis? + answer: >- + Run the example Python query twice with the same key. On the first run, you should see + a message that Redis was updated. On the second, look for `Loaded data from redis`. + - question: How do I check that the provisioned virtual machine uses Arm? + answer: >- + Check the instance type shown by the cloud provider after provisioning. You should see + the Arm-based family selected in the corresponding section. + - question: How do I configure the database after provisioning the virtual machines? + answer: >- + After using `terraform apply` to create the instances, run + `ansible-playbook playbook.yaml -i /tmp/inventory` to install and configure MySQL or + PostgreSQL. + - question: Can I cache PostgreSQL queries on Google Cloud? + answer: >- + Yes. Follow `redis_psql_gcp.md` to provision the Google Cloud environment and configure + Redis as a cache for PostgreSQL. + - question: How long do the examples keep a query result in Redis? + answer: >- + You get a cached result for up to 120 seconds. The example Python scripts set that + expiration when they store a database query result in Redis. +# END generated_summary_faq + author: Jason Andrews -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md b/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md index bca5a069f3..554b062712 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md @@ -1,24 +1,67 @@ --- -title: Learn how to tune Redis +title: Tune Redis performance on Arm minutes_to_complete: 30 who_is_this_for: This is an advanced topic for software developers who want to tune Redis on Arm-based servers and evaluate performance-sensitive configuration settings. learning_objectives: - - Learn about kernel parameters that can impact Redis performance - - Learn about compiler and libraries that can impact Redis performance - - Tune Redis server configuration for improved performance + - Identify kernel parameters that can impact Redis performance. + - Identify compiler and libraries that can impact Redis performance. + - Tune Redis server configuration for improved performance. prerequisites: - - Cloud or bare-metal installation of a Redis server - - Review [Learn how to deploy Redis](/learning-paths/servers-and-cloud-computing/redis/) if you do not already have Redis setup + - Cloud or bare-metal installation of a Redis server on Arm + - Completion of [Learn how to deploy Redis](/learning-paths/servers-and-cloud-computing/redis/) if you don't already have Redis set up + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:04:57Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: d5d0565161d6897a2b00af3ba2261a9b9755468797df67deacd3efe5c0395460 + summary_generated_at: '2026-11-19T16:04:57Z' + summary_source_hash: d5d0565161d6897a2b00af3ba2261a9b9755468797df67deacd3efe5c0395460 + faq_generated_at: '2026-11-19T16:04:57Z' + faq_source_hash: d5d0565161d6897a2b00af3ba2261a9b9755468797df67deacd3efe5c0395460 + summary: >- + You'll tune Redis on Arm-based Linux by measuring the effect of each change. First, you'll + examine kernel settings, compiler options, and OpenSSL choices. You'll then start from a + minimal `redis.conf`, adjust one server setting at a time, and compare throughput, + latency, memory, and CPU use. Finally, you'll evaluate client-side pipelining against your + workload to see whether it improves performance. + faqs: + - question: How do I apply and persist kernel parameter changes? + answer: >- + Use `sysctl -w` to apply a setting immediately. Add it to a file under `/etc/sysctl.d/` + if you want it to persist after a reboot. + - question: How should I compare Redis configuration changes? + answer: >- + Start with the baseline `redis.conf`, change one setting, and measure throughput, + latency, memory use, and CPU use before changing another. + - question: Why isn't one configuration recommended for every workload? + answer: >- + Your request mix and deployment conditions affect the best settings. Measure each option + with your workload before keeping a configuration. + - question: Should I also test compiler and OpenSSL choices? + answer: >- + Yes. Evaluate the compiler and OpenSSL options described in the Learning Path + and compare their measured effect. + - question: How should I test client-side pipelining? + answer: >- + Start with pipeline depth `1`, then test `4`, `8`, `16`, and `32`. Compare throughput, + tail latency, and client-side memory use before choosing a depth for your workload. +# END generated_summary_faq author: - Elham Harirpoush - Kelsey Steele -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false