My Huawei Cloud Practicum Experience

This article is about my experience in the Huawei Cloud Practicum organized by Patika, sponsored by Huawei Cloud.

---

Table of Contents

• Intro
• First Case
• Homeworks
• Final Project
• Conclusion

---

Intro

I am Akın. I am developing myself in cloud computing. During this process, I wanted to add a hands-on experience to my learning process by participating in this practicum. In this blog post, I will describe to you what I did during this process.

This practicum was a 6-week process. To participate in this process, the given case was asked to be done as desired.

---

First Case

We were asked to show how communication is provided by establishing peering connections between the VPCs. Since the case is simple, I created a challenge for myself. Around this time, I was starting to learn Terraform. That's why I wanted to add a hands-on experience to the learning process and develop the infrastructure as code with Terraform.

My first job was to review the code samples on the web and in the terraform-provider-huaweicloud repository and understand the variables in Terraform. After a week, I completed the case. I brought together what I did during the process. You can reach my blog post and terraform codes from these links.

---

Homeworks

During the first two weeks, we completed five exercises in Koolabs. With these exercises, we started to experience and learn Huawei Cloud services with a hands-on approach. In the third week, we did an exercise aiming to use the CCE (Kubernetes) cluster basic features. With this exercise, we experienced the CCE service hands-on.

---

Final Project

In the final project, I converted my monolithic survey management system application, which I had previously developed, into serverless architecture and tried to adapt it to the cloud. You can find my project codes here.

1. Creation of serverless functions
2. Creating a pipeline with DevCloud's CloudPipeline
3. Serverless backend with FunctionGraph
4. Triggering functions with API Gateway
5. Static website hosting with OBS

---

1. Creation of serverless functions

First, I created the internal application logic and serverless functions by separating the API handlers in the monolith app into events.

Structure of the project

survey-builder
 ┣ functions
 ┃ ┣ register
 ┃ ┃ ┗ main.go
 ┃ ┣ ...
 ┃ ┗ ...
 ┣ internal
 ┃ ┣ database
 ┃ ┣ go-runtime
 ┃ ┣ handler
 ┃ ┣ model
 ┃ ┗ service
 ┣ vendor
 ┣ go.mod
 ┗ go.sum

Below is a serverless function example of register event. I handled APIG Trigger events using Huawei Cloud's FunctionGraph SDK. I used GaussDB for NoSQL for the database.

package main

import (
    "bytes"
    "encoding/base64"
    "encoding/json"
    "net/http"

    "huaweicloud.com/akinbe/survey-builder-app/internal/go-runtime/events/apig"
    "huaweicloud.com/akinbe/survey-builder-app/internal/go-runtime/go-api/context"
    "huaweicloud.com/akinbe/survey-builder-app/internal/go-runtime/pkg/runtime"
    "huaweicloud.com/akinbe/survey-builder-app/internal/handler"
)

func RegisterHandler(payload []byte, ctx context.RuntimeContext) (interface{}, error) {
    // Handle Apig Trigger Event Request
    var apigEvent apig.APIGTriggerEvent
    err := json.Unmarshal(payload, &apigEvent)
    if err != nil {
        apigResp := apig.APIGTriggerResponse{
            Body: err.Error(),
            Headers: map[string]string{
                "content-type": "application/json",
            },
            StatusCode: http.StatusBadRequest,
        }
        return apigResp, nil
    }

    // Parse the 'data' value from the trigger event, which takes the 'data' value
    // from the request sent by the client and carries it to the backend.
    // Then, decode the base64 encoded data.
    data, _ := base64.StdEncoding.DecodeString(apigEvent.PathParameters["data"])
    data_str := bytes.NewBuffer(data).String()

    // Event Logic
    viewuser, status, err := handler.UserSignupPostHandler(data_str)
    if err != nil {
        apigResp := apig.APIGTriggerResponse{
            Body: err.Error(),
            Headers: map[string]string{
                "content-type": "application/json",
            },
            StatusCode: status,
        }
        return apigResp, nil
    } else {
        user, _ := json.Marshal(viewuser)
        user_str := string(user)
        apigResp := apig.APIGTriggerResponse{
            Body: user_str,
            Headers: map[string]string{
                "content-type": "application/json",
            },
            StatusCode: http.StatusOK,
        }
        return apigResp, nil
    }
}

func main() {
    runtime.Register(RegisterHandler)
}

---

2. Creating a pipeline with DevCloud's CloudPipeline

With DevCloud's Cloud Pipeline, I built the functions with docker and then transferred the images to SWR. With the container image option in FunctionGraph, I created the functions by pulling them from SWR. You can view the Dockerfile of the register event below.

FROM golang:1.19-alpine AS builder

RUN apk add --update --no-cache gcc git build-base

WORKDIR /src
COPY . /src
RUN CGO_ENABLED=0 go build -o /bin/register

FROM scratch
COPY --from=builder /bin/register /bin/register
ENTRYPOINT ["/bin/register"]

I tested the functions in FunctionGraph. However, I resorted to another method because I was constantly getting the below error and could not find a solution.

function invocation exception, error: CrashLoopBackOff: The application inside the container keeps crashing

I built and packaged the functions with the bash script below.

#! /bin/bash

for dir in functions/*/; do
  # Extract the function name from the directory path
  function_name=$(basename "$dir")
  cd ${GOPATH}/src/huaweicloud.com/akinbe/survey-builder/functions/$function_name
  package="${function_name}_go1.x.zip"
  go build -o handler main.go
  zip $package handler
done

With a Cloud Build task in DevCloud's Cloud Pipeline, I transferred the zip files to OBS (Object Storage Service). I created the functions in FunctionGraph by pulling the zip files from OBS. And then, I tested all functions successfully with APIG events.

---

3. Serverless backend with FunctionGraph

Below is the test case of the register function. It returned an HTTP status of 500 because there is currently no database connection.

---

4. Triggering serverless functions with API Gateway

In API Gateway, I created my APIs in an API Group where each endpoint corresponds to a function. I have configured the backend of the APIs with the functions in the Function Graph.

Below is the test of the register event at the /api/v1/signup endpoint.

---

5. OBS Static Web Site Hosting

I hosted my frontend files in OBS with static website hosting. However, I could not perform a full presentation since I received 405 not allowed responses from the POST requests sent from the client to the APIs.

---

Conclusion

As a result, I tried to implement a project with the Cloud first approach. I implemented a cloud-adapted project using the most appropriate services at every step. With its pros and cons, I tried to create an automated system in DevCloud's Cloud Pipeline, serverless architecture in FunctionGraph, and a gateway that serves backend logic to clients in API Gateway.

In this process, I had the chance to get to know and use Huawei Cloud services hands-on. My thanks to everyone who made this process possible.
See you in my next blog posts... 👋👋