diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/_index.md new file mode 100644 index 000000000..04e201628 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/_index.md @@ -0,0 +1,59 @@ +--- +title: Deploy Django on Google Cloud C4A (Arm-based Axion VMs) + +minutes_to_complete: 30 + +who_is_this_for: This learning path is intended for software developers deploying and optimizing Django-based web applications on Linux/Arm64 environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. + +learning_objectives: + - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors) + - Install Django on a SUSE Arm64 (C4A) instance + - Verify Django functionality by running the development server and accessing the default welcome page on the Arm64 VM + - Measure Django application performance by benchmarking request handling throughput and latency using the official ApacheBench (ab) tool with Gunicorn on Arm64 (Aarch64) + +prerequisites: + - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled + - Basic familiarity with [Django](https://www.djangoproject.com/) + +author: Pareena Verma + +##### Tags +skilllevels: Introductory +subjects: Web +cloud_service_providers: Google Cloud + +armips: + - Neoverse + +tools_software_languages: + - Django + - Python + - Gunicorn + - Apache Bench + +operatingsystems: + - Linux + +# ================================================================================ +# FIXED, DO NOT MODIFY +# ================================================================================ +further_reading: + - resource: + title: Google Cloud documentation + link: https://cloud.google.com/docs + type: documentation + + - resource: + title: Django documentation + link: https://docs.djangoproject.com/ + type: documentation + + - resource: + title: Apache-bench documentation + link: https://httpd.apache.org/docs/2.4/programs/ab.html + type: documentation + +weight: 1 +layout: "learningpathall" +learning_path_main_page: "yes" +--- diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/_next-steps.md new file mode 100644 index 000000000..c3db0de5a --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/_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. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/background.md b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/background.md new file mode 100644 index 000000000..8b2a67418 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/background.md @@ -0,0 +1,27 @@ +--- +title: Getting started with Django on Google Axion C4A (Arm Neoverse-V2) + +weight: 2 + +layout: "learningpathall" +--- + +## Google 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 about Google Axion, refer to the [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu) blog. + +## Django + +[Django](https://www.djangoproject.com/) is a high-level, **open-source Python web framework** that encourages **rapid development** and **clean, pragmatic design**. Developed and maintained by the [Django Software Foundation](https://www.djangoproject.com/foundation/), it simplifies web application development by handling much of the boilerplate and providing powerful built-in features. + +Django follows the **Model–View–Template (MVT)** architectural pattern and includes robust tools for **authentication**, **URL routing**, **form handling**, **ORM (Object Relational Mapping)**, **session management**, and **administration interface** — all out of the box. + +Django is known for its focus on **security**, **scalability**, and **maintainability**, making it suitable for everything from small projects to large-scale enterprise applications. It helps developers build secure, high-performance web applications quickly without reinventing common components. + +Common use cases include **web applications**, **content management systems**, **APIs**, **e-commerce platforms**, and **data-driven dashboards**. It integrates seamlessly with popular databases like **PostgreSQL**, **MySQL**, **SQLite**, and **Oracle**. + +To learn more, visit the [official Django website](https://www.djangoproject.com/) and explore the [Django documentation](https://docs.djangoproject.com/en/stable/). diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/baseline.md b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/baseline.md new file mode 100644 index 000000000..d4efc7367 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/baseline.md @@ -0,0 +1,224 @@ +--- +title: Django Baseline Testing on Google Axion C4A Arm Virtual Machine +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Django Baseline Testing on GCP SUSE VMs +This baseline testing guide verifies that your **Django installation**, **web server**, and **basic application routing** are functioning correctly on a **Google Cloud SUSE Linux Arm64 (Axion C4A)** virtual machine. +You will first run the Django development server and access it from your browser, then create a simple Django app to ensure routing works. + +### Baseline 1 — View Django Welcome Page +This test confirms that Django is installed correctly and the server runs successfully. + +#### Activate your Python environment +Before running Django, activate the Python virtual environment you created during installation. + +```console +source venv/bin/activate +``` + +#### Create a new Django project +Run the following command to create a new Django project named `myproject`: + +```console +django-admin startproject myproject +cd myproject +``` + +This generates the following directory structure: + +```markdown +myproject/ +├── manage.py +└── myproject/ + ├── settings.py + ├── urls.py + ├── asgi.py + └── wsgi.py +``` +- `manage.py` is Django’s command-line utility for project management (running server, migrations, etc.). +- The inner `myproject/` folder contains the core configuration files that define your project’s settings and URLs.- + +#### Run initial migrations +Migrations prepare your project’s database by creating the required tables for Django’s internal apps (admin, authentication, etc.): + +```console +python manage.py migrate +``` + +#### Start the Django development server +Before starting the Django development server, you must configure your ALLOWED_HOSTS setting to allow access from your VM’s external IP. +This ensures that Django accepts HTTP requests from outside the localhost (e.g., when testing in a browser or from another machine). + +**ALLOWED_HOSTS:** is a security setting in Django that defines which host/domain names your Django site can serve. + +- Navigate to Your Project Settings + Move into your Django project directory where the settings.py file is located. + + ```console + cd ~/myproject/mysite/mysite + ``` + +- Open settings.py File + Use any text editor (like vi or nano) to open the file. + + ```console + vi settings.py + ``` + +- Locate the `ALLOWED_HOSTS` Line + Inside the file, find the following line: + + ```python + ALLOWED_HOSTS = [] + ``` + This setting defines which host/domain names Django will serve. + +- Allow All Hosts (for Testing Only) + To make your Django app accessible from your VM’s external IP address, update it to: + ```pthon + ALLOWED_HOSTS = ['*'] + ``` +{{% notice Note %}} +Allowing all hosts `('*')` is suitable **only for development or testing**. +For production, replace `'*'` with specific domain names or IPs, such as: +{{% /notice %}} + +```python +ALLOWED_HOSTS = ['your-external-ip', 'your-domain.com'] +``` + +#### Enable Port 8000 in GCP Firewall + +By default, Google Cloud VMs block external traffic on custom ports like 8000. You must open this port to access Django from your browser. + +**Now start the Django development server:** + +```console +python manage.py runserver 0.0.0.0:8000 +``` + +#### View in browser +Open a web browser on your local machine (Chrome, Firefox, Edge, etc.) and enter the following URL in the address bar: + +```console +http://:8000 +``` +- Replace `` with the public IP of your GCP VM. + +If everything is set up correctly, you should see the default Django welcome page (“The install worked successfully!”). It looks like this: + +![Django welcome page alt-text#center](images/django-welcome-page.png "Figure 1: Django web page") + +### Baseline 2 — Create a Simple Django App +This test ensures Django’s application routing and view rendering work as expected. + +#### Stop the server +Press `Ctrl + C` to stop the Django server if running. + +#### Create a new app +Within your Django project directory, create a new app named `hello`: + +```console +python manage.py startapp hello +``` + +**This creates the following directory:** + +```markdown +hello/ +├── admin.py +├── apps.py +├── models.py +├── tests.py +├── views.py +└── urls.py +``` + +#### Create a simple view +Edit `hello/views.py`. Replace your existing file with this: + +```python +from django.http import HttpResponse + +def home(request): + return HttpResponse("

Hello, Django on GCP SUSE ARM64!

") +``` +This defines a simple view function that sends a basic HTML message as the HTTP response. + +#### Create app URL configuration +Create a new file hello/urls.py and add: + +```python +from django.urls import path +from . import views + +urlpatterns = [ + path('', views.home, name='home'), +] +``` +This maps the root URL `(/)`of your app to the `home()` view function. + +#### Link the app to the main project +Replace your default `myproject/urls.py` file with this version. + +```python +"""myproject URL Configuration + +The `urlpatterns` list routes URLs to views. For more information please see: + https://docs.djangoproject.com/en/3.2/topics/http/urls/ +Examples: +Function views + 1. Add an import: from my_app import views + 2. Add a URL to urlpatterns: path('', views.home, name='home') +Class-based views + 1. Add an import: from other_app.views import Home + 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home') +Including another URLconf + 1. Import the include() function: from django.urls import include, path + 2. Add a URL to urlpatterns: path('blog/', include('blog.urls')) +""" + +from django.contrib import admin +from django.urls import path, include + +urlpatterns = [ + path('admin/', admin.site.urls), + path('', include('hello.urls')), +] +``` +This tells Django to delegate routing for the root path (`''`) to the `hello` app’s URLs. + +#### Add the app to settings +This makes Django aware of your new app so it can load its configuration and routes. +Edit `myproject/settings.py` → add `'hello'` to INSTALLED_APPS: + +```python +INSTALLED_APPS = [ + 'django.contrib.admin', + 'django.contrib.auth', + 'django.contrib.contenttypes', + 'django.contrib.sessions', + 'django.contrib.messages', + 'django.contrib.staticfiles', + 'hello', +] +``` +#### Run the server again + +```console +python manage.py runserver 0.0.0.0:8000 +``` + +#### Test your app +Open in browser: + +```console +http://:8000 +``` +You should see the Django app. It looks like this: + +![Django App alt-text#center](images/django-app.png "Figure 2: Django App") diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/benchmarking.md b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/benchmarking.md new file mode 100644 index 000000000..28325cb90 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/benchmarking.md @@ -0,0 +1,202 @@ +--- +title: Django Benchmarking +weight: 6 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + + +## Django Benchmarking using ApacheBench +This section describes how to benchmark a Django web application deployed with **Gunicorn** using **ApacheBench (ab)** — a lightweight HTTP benchmarking tool. +You will measure **throughput (requests per second)** and **latency (response time)** to evaluate the performance of your Django app on an Arm-based GCP SUSE VM. + +### Ensure ApacheBench is installed +**ApacheBench (ab)** is a command-line tool used to benchmark web servers by simulating multiple HTTP requests. + +Install it using following command: + +```console +sudo zypper install -y apache2-utils +``` +**Verify installation:** + +This confirms ApacheBench is correctly installed and available system-wide. + +```console +ab -V +``` + +### Activate Django Virtual Environment +A virtual environment isolates Python dependencies for your Django project to prevent version conflicts. + +```console +cd ~/myproject +source venv/bin/activate +``` +When activated, your shell prompt should show (`venv`) — indicating you’re inside the virtual environment. + +**Ensure Django and Gunicorn are installed:** + +```console +pip install django gunicorn +``` +- **Django** is the Python web framework you’re benchmarking. +- **Gunicorn** is a high-performance WSGI HTTP server for deploying Django apps in production-like environments. + +### Run Django Migrations and Collect Static Files +Before running the server, initialize the database and prepare static files. + +```console +python manage.py migrate +python manage.py collectstatic --noinput +``` +- `migrate` applies database schema changes (like creating tables). +- `collectstatic` gathers static assets (CSS, JS, images) into a single directory for efficient serving. + +This ensures your Django project is fully configured and ready for deployment under Gunicorn. + +### Run Django with Gunicorn +Use Gunicorn to serve your Django application for benchmarking: + +```console +gunicorn myproject.wsgi:application --bind 0.0.0.0:8000 --workers 4 +``` + +- `--workers 4`: number of worker processes +- `--bind 0.0.0.0:8000`: binds to all interfaces on port 8000 +- Replace `myproject.wsgi:application` with your actual Django project name. + +{{% notice Note %}} +Keep this terminal running during the benchmark. If you’re testing remotely, ensure port 8000 is open in your VM firewall settings. +{{% /notice %}} + +### Benchmark with ApacheBench (ab) +Run ApacheBench to simulate multiple clients hitting your Django server. + +```console +ab -n 1000 -c 10 http://127.0.0.1:8000/ +``` +- `-n 1000`: total number of requests +- `-c 10`: concurrency (simultaneous requests) + +You should see an output similar to: + +```output +This is ApacheBench, Version 2.3 <$Revision: 1903618 $> +Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ +Licensed to The Apache Software Foundation, http://www.apache.org/ + +Benchmarking 127.0.0.1 (be patient) +Completed 100 requests +Completed 200 requests +Completed 300 requests +Completed 400 requests +Completed 500 requests +Completed 600 requests +Completed 700 requests +Completed 800 requests +Completed 900 requests +Completed 1000 requests +Finished 1000 requests + + +Server Software: gunicorn +Server Hostname: 127.0.0.1 +Server Port: 8000 + +Document Path: / +Document Length: 41 bytes + +Concurrency Level: 10 +Time taken for tests: 0.104 seconds +Complete requests: 1000 +Failed requests: 0 +Total transferred: 280000 bytes +HTML transferred: 41000 bytes +Requests per second: 9651.21 [#/sec] (mean) +Time per request: 1.036 [ms] (mean) +Time per request: 0.104 [ms] (mean, across all concurrent requests) +Transfer rate: 2639.00 [Kbytes/sec] received + +Connection Times (ms) + min mean[+/-sd] median max +Connect: 0 0 0.1 0 1 +Processing: 0 1 0.3 1 4 +Waiting: 0 1 0.3 1 3 +Total: 0 1 0.4 1 5 + +Percentage of the requests served within a certain time (ms) + 50% 1 + 66% 1 + 75% 1 + 80% 1 + 90% 1 + 95% 2 + 98% 2 + 99% 3 + 100% 5 (longest request) +``` + +### Benchmark Metrics Explanation + +- **Concurrency Level:** Number of requests executed simultaneously during the test. +- **Time Taken for Tests:** Total time required to complete all HTTP requests. +- **Complete Requests:** Total number of successful requests processed. +- **Failed Requests:** Number of requests that failed or returned errors. +- **Total Transferred:** Total amount of data (including headers) sent and received. +- **HTML Transferred:** Amount of actual response content transferred. +- **Requests per Second:** Average number of requests handled by the server per second. +- **Time per Request (mean):** Average time taken to process a single request. +- **Time per Request (across concurrent):** Mean time per request across all concurrent clients. +- **Transfer Rate:** Average network data throughput during the benchmark. + +### Benchmark summary on x86_64 +To compare the benchmark results, the following results were collected by running the same benchmark on a `x86 - c4-standard-4` (4 vCPUs, 15 GB Memory) x86_64 VM in GCP, running SUSE: + +| **Parameter** | **Description** | **Value** | +|----------------|------------------|-----------| +| **Server Software** | Web server used for serving Django | gunicorn | +| **Server Hostname** | Host address tested | 127.0.0.1 | +| **Server Port** | Port number for benchmark | 8000 | +| **Document Path** | Endpoint used for testing | / | +| **Document Length** | Size of each response | 12068 bytes | +| **Concurrency Level** | Number of concurrent requests | 10 | +| **Time Taken for Tests** | Total time to complete all requests | 0.364 seconds | +| **Complete Requests** | Total number of successful requests | 1000 | +| **Failed Requests** | Number of failed requests | 0 | +| **Total Transferred** | Total bytes transferred (including headers) | 12,351,000 bytes | +| **HTML Transferred** | Total HTML body bytes transferred | 12,068,000 bytes | +| **Requests per Second (mean)** | Throughput — higher is better | **2750.72 req/sec** | +| **Time per Request (mean)** | Average time for each request | **3.635 ms** | +| **Time per Request (across all concurrent requests)** | Average latency considering concurrency | **0.364 ms** | +| **Transfer Rate** | Network throughput rate | **33,177.89 KB/sec** | + +### Benchmark summary on Arm64 +Results from the earlier run on the `c4a-standard-4` (4 vCPU, 16 GB memory) Arm64 VM in GCP (SUSE): + +| **Parameter** | **Description** | **Value** | +|----------------|------------------|-----------| +| **Server Software** | Web server used for serving Django | gunicorn | +| **Server Hostname** | Host address tested | 127.0.0.1 | +| **Server Port** | Port number for benchmark | 8000 | +| **Document Path** | Endpoint used for testing | / | +| **Document Length** | Size of each response | 41 bytes | +| **Concurrency Level** | Number of concurrent requests | 10 | +| **Time Taken for Tests** | Total time to complete all requests | 0.104 seconds | +| **Complete Requests** | Total number of successful requests | 1000 | +| **Failed Requests** | Number of failed requests | 0 | +| **Total Transferred** | Total bytes transferred (including headers) | 280000 bytes | +| **HTML Transferred** | Total HTML body bytes transferred | 41000 bytes | +| **Requests per Second (mean)** | Throughput — higher is better | **9651.21 req/sec** | +| **Time per Request (mean)** | Average time for each request | **1.036 ms** | +| **Time per Request (across all concurrent requests)** | Average latency considering concurrency | **0.104 ms** | +| **Transfer Rate** | Network throughput rate | **2639.00 KB/sec** | + +### Django benchmarking comparison on Arm64 and x86_64 + +- **Exceptional Throughput:** The Arm64 VM efficiently handled nearly 10K requests per second, showcasing excellent concurrency handling. +- **Low Latency:** Average response time stayed around 1 ms, indicating rapid request processing even under load. +- **High Efficiency:** Zero failed requests demonstrate stable and reliable performance under benchmark conditions. +- **Optimized Networking:** Strong data transfer rate highlights Arm64’s efficient network I/O capabilities. +- **Ideal for Scalable Apps:** The consistent and predictable response times make Arm64 VMs well-suited for high-performance web workloads. diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/django-app.png b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/django-app.png new file mode 100644 index 000000000..327ca97e3 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/django-app.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/django-welcome-page.png b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/django-welcome-page.png new file mode 100644 index 000000000..ce0e415a3 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/django-welcome-page.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/gcp-vm.png b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/gcp-vm.png new file mode 100644 index 000000000..0d1072e20 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/images/gcp-vm.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/installation.md b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/installation.md new file mode 100644 index 000000000..808da5da4 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/installation.md @@ -0,0 +1,80 @@ +--- +title: Install Django +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Install Django on GCP VM +This guide walks you through installing Django on a **Google Cloud Platform (GCP) SUSE Linux Arm64 VM**, including all dependencies, Python setup, and environment preparation. + +### Update Your System +Before installing Django, it’s good practice to update your package list and upgrade installed software to ensure you have the latest versions and security patches. + +```console +sudo zypper refresh +sudo zypper update -y +``` + +### Install Python and Tools +**Django** requires **Python 3.10+**. We will use Python 3.11, which is compatible with Django 5. +You will also install `pip` for package management, and basic developer tools (`git`, `gcc`, and `make`) to build Python packages and work with Django projects. +```console +sudo zypper install -y python311 python311-pip python311-devel +sudo zypper install -y git gcc make +``` + +**Use Python 3.11 as the Default (optional):** + +If multiple Python versions exist on your system, you can set Python 3.11 as your default Python 3 interpreter using **update-alternatives**. + +```console +sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 +sudo update-alternatives --config python3 +``` + +**Ensure that both Python and pip are installed correctly:** + +```console +python3 --version +pip3 --version +``` + +You should see an output similar to: +```output +Python 3.11.13 +pip 22.3.1 from /usr/lib/python3.11/site-packages/pip (python 3.11) +``` + +### Create a Project Folder and Virtual Environment +It’s recommended to create a dedicated project directory and use a **virtual environment** to isolate project dependencies. + +```console +mkdir ~/myproject && cd ~/myproject +python3 -m venv venv +source venv/bin/activate +``` +- `python3 -m venv venv` — creates a virtual environment named venv inside your project folder. +- `source venv/bin/activate` — activates the virtual environment. +Once activated, your command prompt will show (venv) at the beginning, indicating that you’re working inside an isolated Python environment. + +### Upgrade Pip and Install Django +With your virtual environment active, upgrade pip and install Django using the following commands: + +```console +pip3 install --upgrade pip +pip3 install django +``` + +**Confirm that Django is installed correctly by checking its version:** + +```console +django-admin --version +``` + +You should see an output similar to: +```output +5.2.7 +``` +Django is installed successfully and ready for project setup. diff --git a/content/learning-paths/servers-and-cloud-computing/django-on-gcp/instance.md b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/instance.md new file mode 100644 index 000000000..2b93bc950 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/django-on-gcp/instance.md @@ -0,0 +1,31 @@ +--- +title: Create a Google Axion C4A Arm virtual machine on GCP +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Overview + +In this section, you will learn how to provision a Google Axion C4A Arm virtual machine on Google Cloud Platform (GCP) using the `c4a-standard-4` (4 vCPUs, 16 GB memory) machine type in the Google Cloud Console. + +{{% notice Note %}} +For support on GCP setup, see the Learning Path [Getting started with Google Cloud Platform](https://learn.arm.com/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. + + ![Create a Google Axion C4A Arm virtual machine in the Google Cloud Console with c4a-standard-4 selected alt-text#center](images/gcp-vm.png "Creating a Google Axion C4A Arm virtual machine in Google Cloud Console") + +- Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**. Pick the preferred version for your Operating System. Ensure you select the **Arm image** variant. Click **Select**. +- Under **Networking**, enable **Allow HTTP traffic**. +- Click **Create** to launch the instance.