Golang 函数在云计算场景下的应用实践

package main

import (
    "context"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"

    compute "cloud.google.com/go/compute/apiv1"
    storage "cloud.google.com/go/storage"
)

// ResizeEvent represents the data sent to the function.
type ResizeEvent struct {
    Name     string `json:"name"`
    Bucket   string `json:"bucket"`
    MimeType string `json:"mimeType"`
    Size     int64  `json:"size"`
}

// resizeImage resizes an image to a given size.
func resizeImage(w io.Writer, event ResizeEvent) error {
    // Get the dimensions of the image.
    img := compute.NewImagesRESTClient(context.Background())
    image, err := img.Get(context.Background(), event.Project, event.Zone, event.Name)
    if err != nil {
        return err
    }

    // Get the bytes of the image.
    src := storage.NewClient(context.Background())
    srcBucket := src.Bucket(event.Bucket)
    srcObj := srcBucket.Object(event.Name)
    r, err := srcObj.NewReader(context.Background())
    if err != nil {
        return err
    }
    defer r.Close()
    imgBytes, err := ioutil.ReadAll(r)
    if err != nil {
        return err
    }

    // Resize the image.
    resized, err := resize.Resize(imgBytes, 256, 256, resize.Lanczos3)
    if err != nil {
        return err
    }

    // Upload the resized image to a new bucket.
    dstBucket := src.Bucket("resized-images")
    dstObj := dstBucket.Object(event.Name)
    w = dstObj.NewWriter(context.Background())
    w.Header().Set("Content-Type", event.MimeType)
    if _, err := w.Write(img); err != nil {
        return err
    }
    if err := w.Close(); err != nil {
        return err
    }

    fmt.Fprintf(w, "Resized image: %s/%s", dstBucket.Name(), event.Name)
    return nil
}

func main() {
    me, err := metadata.NewClient(context.Background())
    if err != nil {
        log.Fatal(err)
    }
    projectID, err := me.ProjectID()
    if err != nil {
        log.Fatal(err)
    }
    functionName, ok := os.LookupEnv("FUNCTION_NAME")
    if !ok {
        log.Fatal("FUNCTION_NAME environment variable not set.")
    }
    zone, ok := os.LookupEnv("FUNCTION_REGION")
    if !ok {
        log.Fatal("FUNCTION_REGION environment variable not set.")
    }
    // Set the namespace for the function. This is needed to make the function visible to other functions in the same project.
    os.Setenv("K_NAMESPACE", projectID+"-"+functionName)

    // Set up a Pub/Sub subscription to listen for image resize events.
    subName := "my-resize-subscription"
    topicName := "my-resize-topic"
    topicPath := fmt.Sprintf("projects/%s/topics/%s", projectID, topicName)
    subPath := fmt.Sprintf("projects/%s/subscriptions/%s", projectID, subName)
    subClient, err := pubsub.NewClient(context.Background(), projectID)
    if err != nil {
        log.Fatal(err)
    }
    sub, err := subClient.CreateSubscription(context.Background(), subName, pubsub.SubscriptionConfig{
        Topic: &topicPath,
    })
    if err != nil {
        log.Fatal(err)
    }
    defer subClient.Close()
    ctx := context.Background()
    it := sub.Receive(ctx)
    for {
        select {
        case msg := <-it:
            event := ResizeEvent{}
            if err := json.Unmarshal(msg.Data, &event); err != nil {
                log.Printf("Error unmarshaling event: %v", err)
                msg.Nack()
                continue
            }
            if err := resizeImage(ctx, event); err != nil {
                log.Printf("Error resizing image: %v", err)
                msg.Nack()
                continue
            }
            msg.Ack()
        case <-ctx.Done():
            break
        case time.Sleep(10 * time.Millisecond):
        }
    }
}

gcloud functions deploy resize-image --runtime go113 --trigger-topic my-resize-topic