Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.
Guida rapida: creazione e creazione di un job Go in Cloud Run

Creare e creare un job Go in Cloud Run

Scopri come creare un semplice job di Cloud Run, pacchettizzarlo in un'immagine container, caricare l'immagine del 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 pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

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

  4. Installa e inizializza Google Cloud CLI.
  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Installa e inizializza Google Cloud CLI.

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 del job effettivo. Copia le seguenti righe di esempio al suo interno:

    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 un sottoinsieme di dati in modo indipendente.

    Ogni attività è a conoscenza del suo indice, archiviato 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 di questa attività, partendo da 0 per il primo tentativo e incrementando di 1 per ogni nuovo tentativo successivo, fino a --max-retries.

    Il codice consente anche di generare errori per testare i nuovi tentativi e generare log di errore in modo da poter vedere l'aspetto che hanno.

  3. Crea un file go.mod con il seguente contenuto:

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

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

Crea il job dei job e invialo al repository

Importante: questa guida rapida presuppone che tu abbia i ruoli di proprietario o di editor nel progetto che stai utilizzando per la guida rapida. In caso contrario, consulta le autorizzazioni di deployment di Cloud Run, le autorizzazioni di Cloud Build e le 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 beta 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

dove PROJECT_ID è il tuo ID progetto e REGION è la tua regione, ad esempio us-central1. Tieni presente che puoi modificare i vari parametri con i valori da utilizzare ai fini dei test. SLEEP_MS simula il lavoro e FAIL_RATE comporta un errore pari a X% delle attività, così puoi sperimentare con il parallelismo e riprovare a eseguire le attività non riuscite.

Eseguire un job in Cloud Run

Per eseguire il job appena creato:

gcloud beta run jobs execute job-quickstart

Quando ti viene richiesta un'area geografica, seleziona l'area geografica che preferisci, ad esempio us-central1.

Esegui test in locale

Puoi eseguire il job in locale:

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 saperne di più sulla creazione di un container da un'origine codice e sul push in un repository, consulta: