Merge pull request #2266 from annietllnd/github_LP

Tech review of Axion and GitHub Self-Hosted Runner

Author: pareenaverma

content/learning-paths/servers-and-cloud-computing/github-on-arm/_index.md

@@ -5,9 +5,9 @@ draft: true
 cascade:
     draft: true
 
-minutes_to_complete: 30
+minutes_to_complete: 15
 
-who_is_this_for: This Learning Path is for DevOps engineers, system administrators, or developers who want to deploy GitHub Actions Self-Hosted Runner on the Google Axion C4A Arm virtual machine.
+who_is_this_for: This is an introductory topic for developers who want to deploy GitHub Actions Self-Hosted Runner on an Arm-based Google Axion C4A instance.
 
 learning_objectives:
        - Provision an Arm virtual machine on the Google Cloud Platform using the C4A Google Axion instance family.
@@ -16,13 +16,12 @@ learning_objectives:
 
 prerequisites:
      - A [Google Cloud Platform (GCP)](https://cloud.google.com/free?utm_source=google&hl=en) account with billing enabled.
-     - Familiarity with [GitHub Actions](https://github.com/features/actions) and the Linux command line.
-     - A GitHub account. You can sign up [here](https://github.com/signup).     
+     - A GitHub account. You can sign up [here](https://github.com/signup).
 
-author: Jason Andrews
+author: Annie Tallund
 
 ##### Tags
-skilllevels: Advanced
+skilllevels: Introductory
 subjects: CI-CD
 cloud_service_providers: Google Cloud
 
@@ -55,6 +54,11 @@ further_reading:
         link: https://github.blog/news-insights/product-news/arm64-on-github-actions-powering-faster-more-efficient-build-systems/
         type: website
 
+    - resource:
+        title: GCP Quickstart Guide to Create a virtual machine
+        link: https://cloud.google.com/compute/docs/instances/create-start-instance
+        type: website
+
 
 weight: 1                       # _index.md always has weight of 1 to order correctly
 layout: "learningpathall"       # All files under learning paths have this same wrapper

content/learning-paths/servers-and-cloud-computing/github-on-arm/background.md

@@ -1,5 +1,5 @@
 ---
-title: "About Google Axion C4A series and GitHub Actions"
+title: "About Google Axion and GitHub Actions"
 
 weight: 2
 
@@ -10,7 +10,7 @@ layout: "learningpathall"
 
 The Google Axion C4A series 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 ideal 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 machine while leveraging the scalability and performance benefits of the Arm architecture in Google Cloud.
+The C4A series provides offer a cost-effective virtual machine while leveraging the scalability and performance benefits of the Arm architecture in Google Cloud.
 
 To learn more about Google Axion, refer to the blog [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu).
 

content/learning-paths/servers-and-cloud-computing/github-on-arm/deploy.md

@@ -1,77 +1,86 @@
 ---
-title: Install and Set Up GitHub Self-Hosted Runner on Google Cloud C4A Virtual Machine
+title: Set up a GitHub Self-Hosted Runner
 weight: 4
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
 
-## Set Up GitHub Actions Self-Hosted Runner on Google Axion C4A Virtual Machine
+This section shows how to deploy a self-hosted GitHub Actions runner on your instance. It covers installing Git and GitHub CLI, authenticating with GitHub and configuring the runner on an Arm64 environment for optimized CI/CD workflows.
 
-This Learning Path shows how to deploy a self-hosted GitHub Actions runner on a Google Cloud C4A Arm64 virtual machine running Ubuntu. It covers installing Git and GitHub CLI, authenticating with GitHub and configuring the runner on an Arm64 environment for optimized CI/CD workflows.
+### Set up development environment
+
+Start by installing the required dependencies using the `apt` package manager:
 
-### Install Git and GitHub CLI 
 ```console
-sudo apt update 
-sudo apt install -y git gh
+sudo apt update
+sudo apt install -y git gh vim
+```
+
+Next step is to configure your git credentials. Update the command with your name and email.
+
+```bash
+git config --global user.email "you@example.com"
+git config --global user.name "Your Name"
 ```
-Login to GitHub
+
+Now you are ready to connect the machine to GitHub. The command below is used to authenticate the GitHub CLI with your GitHub account. It allows you to securely log in using a web browser or token, enabling the CLI to interact with repositories, actions, and other GitHub features on your behalf.
+
+
 ```console
-gh auth login 
- ```
-The command `gh auth login` is used to authenticate the GitHub CLI with your GitHub account. It allows you to securely log in using a web browser or token, enabling the CLI to interact with repositories, actions, and other GitHub features on your behalf.
+gh auth login
+```
+
+The command will prompt you to make a few choices. For this use-case, you can use the default ones as shown in the image below.
 
 ![Login to GitHub](./images/gh-auth.png)
 
-Below is the GitHub login UI:
+{{% notice %}}
+If you get an error opening the browser on your virtual machine, you can navigate to the following URL on the host machine.
+```
+https://github.com/login/device
+```
+From there, you can enter the code displayed in the CLI of the virtual machine.
+{{% /notice %}}
+
+If the log in was successful, you will see the following confirmation in your browser window.
 
 ![GitHub UI](./images/login-page.png)
 
-### Test GitHub CLI and Git 
-Create a test repo: 
+### Test GitHub CLI and Git
+
+The command below creates a new public GitHub repository named **test-repo** using the GitHub CLI. It sets the repository visibility to public, meaning anyone can view it
+
 ```console
-gh repo create test-repo –public
+gh repo create test-repo --public
 ```
 You should see an output similar to:
 ```output
 ✓ Created repository <your-github-account>/test-repo on GitHub
   https://github.com/<your-github-account>/test-repo
 ```
 
-The command `gh repo create test-repo --public` creates a new public GitHub repository named **test-repo** using the GitHub CLI. It sets the repository visibility to public, meaning anyone can view it 
 
 ### Configure the Self-Hosted Runner
-Go to your repository's **Settings > Actions**, and under the **Runners** section, click on **Add Runner** or view existing self-hosted runners.
+
+* Go to your repository's **Settings > Actions**, and under the **Runners** section
+* Click on **Add Runner** or view existing self-hosted runners.
+
+{{% notice Note %}}
 If the **Actions** tab is not visible, ensure Actions are enabled by navigating to **Settings > Actions > General**, and select **Allow all actions and reusable workflows**.
+{{% /notice %}}
 
 ![runner](./images/newsh-runner.png)
 
-Then, click on the **New runner** button, followed by **New self-hosted runner**. In the **Add new self-hosted runner** section, proceed as follows:
-- Select Linux for the operating system.
-- Choose ARM64 for the architecture
+Then, click on the **New self-hosted runner** button. In the **Add new self-hosted runner** section. Select Linux for the operating system, and choose ARM64 for the architecture. This will generate commands to set up the runner. Copy and run them on your Google Axion C4A virtual machine.
 
 ![new-runner](./images/new-runner.png)
 
-Next, execute the following instructions on your Google Axion C4A virtual machine:
-```console
-mkdir actions-runner && cd actions-runner# Download the latest runner package
-curl -o actions-runner-linux-arm64-2.326.0.tar.gz -L https://github.com/actions/runner/releases/download/v2.326.0/actions-runner-linux-arm64-2.326.0.tar.gz
-echo "ee7c229c979c5152e9f12be16ee9e83ff74c9d9b95c3c1aeb2e9b6d07157ec85  actions-runner-linux-arm64-2.326.0.tar.gz" | shasum -a 256 -c# Extract the installer
-tar xzf ./actions-runner-linux-arm64-2.326.0.tar.gz
-```
-Then, configure the virtual machine with the following command:
-
-```console
-./config.sh --url https://github.com/<YOUR_USERNAME>/YOUR_REPO --token YOUR_TOKEN
-```
-Replace `YOUR_USERNAME`, `YOUR_REPO`, and `YOUR_TOKEN` accordingly.
-This command links the runner to your GitHub repo using a one-time registration token.
+The final command links the runner to your GitHub repo using a one-time registration token.
 
 During the command’s execution, you will be prompted to provide the runner group, the name of the runner, and the work folder name. You can accept the defaults by pressing **Enter** at each step. The output will resemble as below:
 
-You should see an output similar to:
-
 ```output
 --------------------------------------------------------------------------------
 |        ____ _ _   _   _       _          _        _   _                      |
@@ -111,3 +120,5 @@ Current runner version: '2.326.0'
 The runner will now be visible in the GitHub actions:
 
 ![final-runner](./images/final-runner.png)
+
+For now, you can terminate the `./run.sh` command with `Ctrl+C`. Move on to the next section to set up a simple web server using the runner.

content/learning-paths/servers-and-cloud-computing/github-on-arm/images/new-runner.png

@@ -1,5 +1,5 @@
 ---
-title: Create Google Axion C4A Arm virtual machine
+title: Create the instance
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -10,20 +10,24 @@ layout: learningpathall
 
 This guide walks you through provisioning **Google Axion C4A Arm virtual machine** on GCP with the **c4a-standard-4 (4 vCPUs, 16 GB Memory)** machine type, using the **Google Cloud Console**.
 
-If you are new to Google Cloud, it is recommended to follow the [GCP Quickstart Guide to Create a virtual machine](https://cloud.google.com/compute/docs/instances/create-start-instance).
-
-For more details, kindly follow the Learning Path on [Getting Started with Google Cloud Platform](https://learn.arm.com/learning-paths/servers-and-cloud-computing/csp/google/).
+If you haven't got a Google Cloud account, you can follow the Learning Path on [Getting Started with Google Cloud Platform](https://learn.arm.com/learning-paths/servers-and-cloud-computing/csp/google/) to get started.
 
 ### Create an Arm-based Virtual Machine (C4A)
 
 To create a virtual machine based on the C4A Arm architecture:
-1. Navigate to the [Google Cloud Console](https://console.cloud.google.com/).
-2. Go to **Compute Engine > VM Instances** and click on **Create Instance**. 
+1. Open the [Google Cloud Console](https://console.cloud.google.com/).
+2. Navigate to the card **Compute Engine** and click on **Create Instance**.
 3. Under the **Machine Configuration**:
       - Fill in basic details like **Instance Name**, **Region**, and **Zone**.
       - Choose the **Series** as `C4A`.
       - Select a machine type such as `c4a-standard-4`.
-![Instance Screenshot](./images/image.png)
-4. Under the **OS and Storage**, click on **Change**, and select Arm64 based OS Image of your choice. For this Learning Path, we pick **Ubuntu** as the Operating System with **Ubuntu 24.04 LTS Minimal** as the Version. Make sure you pick the version of image for Arm.
+![Instance Screenshot](./images/select-instance.png)
+4. Under the **OS and Storage**, click on **Change**, pick **Ubuntu** as the Operating System with **Ubuntu 24.04 LTS Minimal** as the Version. Make sure you pick the version of image for Arm.
 5. Under **Networking**, enable **Allow HTTP traffic** to test workloads like NGINX later.
 6. Click on **Create**, and the instance will launch.
+
+{{% notice Important %}}
+You should not enable the **Allow HTTP traffic** permanently, since this poses a security risk. For the long-term, you should only allow traffic from the IP address you use to connect to the instance.
+{{% /notice %}}
+
+You can access the Google Cloud Console by clicking the **SSH** button in the instance overview. Use this command line interface (CLI) to run the commands in the remainder of this Learning Path.

…computing/github-on-arm/images/image.png …github-on-arm/images/select-instance.pngcontent/learning-paths/servers-and-cloud-computing/github-on-arm/images/image.png renamed to content/learning-paths/servers-and-cloud-computing/github-on-arm/images/select-instance.png content/learning-paths/servers-and-cloud-computing/github-on-arm/images/image.png renamed to content/learning-paths/servers-and-cloud-computing/github-on-arm/images/select-instance.png

@@ -1,21 +1,31 @@
 ---
-title: Deploy NGINX on Self-Hosted Runner Using GitHub Actions
+title: Deploy NGINX the GitHub Runner
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
 
-## Deploy NGINX Using GitHub Actions
-This workflow installs and starts the NGINX web server on a self-hosted runner whenever code is pushed to the main branch.
+This workflow installs and starts a basic NGINX web server on a self-hosted runner whenever code is pushed to the main branch.
 
-### Create the Workflow:
+In your instance's console, create a directory for the repository:
 
-Create a workflow file at `.github/workflows/deploy-nginx.yaml` with the following content:
+```console
+mkdir test-repo && cd test-repo
+echo "# test-repo" >> README.md
+```
 
-```yaml
+Then, create the GitHub Actions workflow file at `.github/workflows/deploy-nginx.yaml`.
+
+```console
+mkdir .github  && mkdir .github/workflows/
+vim .github/workflows/deploy-nginx.yaml
+```
 
+Paste the following code block into the file and save it.
+
+```yaml
 name: Deploy NGINX
 
 on:
@@ -34,18 +44,34 @@ jobs:
       - name: Start NGINX
         run: sudo systemctl start nginx
 ```
-### Commit and Push:
 
- ```console
+Now it's time to initiate your repository and push the changes.
+
+```console
+git init
 git add .
-git commit -m "Add NGINX deploy workflow"
-git push origin main
+git commit -m "first commit"
+git branch -M main
+git remote add origin https://github.com/annietllnd/test-repo.git
+git push -u origin main
 ```
+
+This will trigger an actions job. The job will listen for a self-hosted runner to connect to the GitHub repository. Go back to the `actions-runner` directory and re-run the script from the previous section:
+
+```bash
+cd ..
+./run.sh
+```
+
+You will see in the output of the command that it identifies the a job called `deploy`, and that it finishes after having run the two steps.
+
 ### Access the NGINX Server
-Once the workflow completes, open your browser and navigate to:
+Once the workflow completes, open your browser and navigate to your machine's external IP address. You will find the information in your instance overview, under **Network interfaces**.
 ```
 http://<your-public-IP>
 ```
 You should see the NGINX welcome page confirming a successful deployment.
 
 ![nginx](./images/nginx.png)
+
+You should now know how to set up a self-hosted runner with an Arm-based Google Cloud instance, and use it to run GitHub Actions workflows. From here, you can modify the workflow file to try out different commands.