Guida rapida: crea e crea un job Go in Cloud Run

Creare e creare un job Go in Cloud Run

Scopri come creare un semplice job Cloud Run, pacchettizzarlo in un'immagine container, caricare l'immagine container in Container Registry ed eseguire il deployment in Cloud Run. Puoi utilizzare altre lingue oltre a quelle mostrate.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. Nella console di Google Cloud Console, nella pagina del selettore dei progetti, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.

  4. Installa Google Cloud CLI.

  5. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente: 

    gcloud init
    6.

  6. Nella console di Google Cloud Console, nella pagina del selettore dei progetti, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  7. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.

  8. Installa Google Cloud CLI.

  9. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente: 

    gcloud init
    10.

Scrittura del job di esempio

Per scrivere un job in Go:

  1. Crea una nuova directory denominata jobs e modificala al suo interno:

    mkdir jobs
cd jobs

  2. Nella stessa directory, crea un file main.go per il codice effettivo del job. Copia al suo interno le seguenti righe di esempio:

    run/jobs/main.go 
    package main

import (
	"fmt"
	"log"
	"math/rand"
	"os"
	"strconv"
	"time"
)

type Config struct {
	// Job-defined
	taskNum    string
	attemptNum string

	// User-defined
	sleepMs  int64
	failRate float64
}

func configFromEnv() (Config, error) {
	// Job-defined
	taskNum := os.Getenv("CLOUD_RUN_TASK_INDEX")
	attemptNum := os.Getenv("CLOUD_RUN_TASK_ATTEMPT")
	// User-defined
	sleepMs, err := sleepMsToInt(os.Getenv("SLEEP_MS"))
	failRate, err := failRateToFloat(os.Getenv("FAIL_RATE"))

	if err != nil {
		return Config{}, err
	}

	config := Config{
		taskNum:    taskNum,
		attemptNum: attemptNum,
		sleepMs:    sleepMs,
		failRate:   failRate,
	}
	return config, nil
}

func sleepMsToInt(s string) (int64, error) {
	sleepMs, err := strconv.ParseInt(s, 10, 64)
	return sleepMs, err
}

func failRateToFloat(s string) (float64, error) {
	// Default empty variable to 0
	if s == "" {
		return 0, nil
	}

	// Convert string to float
	failRate, err := strconv.ParseFloat(s, 64)

	// Check that rate is valid
	if failRate < 0 || failRate > 1 {
		return failRate, fmt.Errorf("Invalid FAIL_RATE value: %f. Must be a float between 0 and 1 inclusive.", failRate)
	}

	return failRate, err
}

func main() {
	config, err := configFromEnv()
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("Starting Task #%s, Attempt #%s ...", config.taskNum, config.attemptNum)

	// Simulate work
	if config.sleepMs > 0 {
		time.Sleep(time.Duration(config.sleepMs) * time.Millisecond)
	}

	// Simulate errors
	if config.failRate > 0 {
		if failure := randomFailure(config); failure != nil {
			log.Fatalf("%v", failure)
		}
	}

	log.Printf("Completed Task #%s, Attempt #%s", config.taskNum, config.attemptNum)
}

// Throw an error based on fail rate
func randomFailure(config Config) error {
	rand.Seed(time.Now().UnixNano())
	randomFailure := rand.Float64()

	if randomFailure < config.failRate {
		return fmt.Errorf("Task #%s, Attempt #%s failed.", config.taskNum, config.attemptNum)
	}
	return nil
}

    I job Cloud Run consentono agli utenti di specificare il numero di attività da eseguire. Questo codice campione mostra come utilizzare la variabile di ambiente CLOUD_RUN_TASK_INDEX integrata. Ogni attività rappresenta una copia in esecuzione del container. Tieni presente che le attività vengono generalmente eseguite in parallelo. L'utilizzo di più attività è utile se ogni attività può elaborare in modo indipendente un sottoinsieme dei tuoi dati.

    Ogni attività è a conoscenza del suo indice, archiviata nella variabile di ambiente CLOUD_RUN_TASK_INDEX. La variabile di ambiente CLOUD_RUN_TASK_COUNT integrata contiene il numero di attività fornite al momento dell'esecuzione del job tramite il parametro --tasks.

    Il codice mostrato mostra anche come riprovare le attività, utilizzando la variabile di ambiente CLOUD_RUN_TASK_ATTEMPT integrata, che contiene il numero di nuovi tentativi per l'attività, a partire da 0 per il primo tentativo e aumentando di 1 per ogni nuovo tentativo, fino a un massimo di --max-retries.

    Il codice consente inoltre di generare errori per testare i nuovi tentativi e generare log degli errori in modo da poterne verificare l'aspetto.

  3. Crea un file go.mod con i seguenti contenuti:

    module github.com/GoogleCloudPlatform/golang-samples/run/jobs

go 1.19

Il codice è completo e pronto per essere pacchettizzato in un contenitore.

Crea un container di job e invialo al repository

Importante: questa guida rapida presuppone che tu abbia i ruoli di proprietario o editor nel progetto che utilizzi per la guida rapida. In caso contrario, fai riferimento alle autorizzazioni di deployment di Cloud Run, alle autorizzazioni di Cloud Build e alle autorizzazioni di Artifact Registry per le autorizzazioni richieste.

Utilizza un buildpack per creare il container:

gcloud builds submit --pack image=gcr.io/PROJECT_ID/logger-job

Crea un job in Cloud Run

Per creare un job utilizzando il container appena creato:

gcloud run jobs create job-quickstart \
    --image gcr.io/PROJECT_ID/logger-job \
    --tasks 50 \
    --set-env-vars SLEEP_MS=10000 \
    --set-env-vars FAIL_RATE=0.5 \
    --max-retries 5 \
    --region REGION \
    --project=PROJECT_ID

dove PROJECT_ID è il tuo ID progetto e REGION è la tua regione, ad esempio us-central1. Tieni presente che puoi modificare i vari parametri impostandoli sui valori che vuoi usare ai fini del test. SLEEP_MS simula il lavoro e FAIL_RATE causa un errore di X% delle attività in modo che tu possa sperimentare con il parallelismo e riprovare le attività non riuscite.

Eseguire un job in Cloud Run

Per eseguire il job appena creato:

gcloud run jobs execute job-quickstart

Quando ti viene chiesta una regione, seleziona l'area geografica di tua scelta, ad esempio us-central1.

Esegui test locale

Puoi eseguire il job localmente:

docker run --rm -e FAIL_RATE=0.9 -e SLEEP_MS=1000 gcr.io/PROJECT_ID/logger-job
dove PROJECT_ID è l'ID progetto.

Passaggi successivi

Per ulteriori informazioni sulla creazione di un container da un codice sorgente e sul push a un repository, consulta: