Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.
Guia de início rápido: desenvolver e criar um job do Go no Cloud Run

Desenvolver e criar um job do Go no Cloud Run

Saiba como criar um job simples do Cloud Run, empacotá-lo em uma imagem de contêiner, fazer o upload da imagem do contêiner para o Container Registry e implantá-lo no Cloud Run. É possível usar outros idiomas além dos mostrados.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

  4. Instale e inicialize a Google Cloud CLI.
  5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  6. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

  7. Instale e inicialize a Google Cloud CLI.

Como gravar o job de amostra

Para gravar um job no Go, faça o seguinte:

  1. Crie um novo diretório com o nome jobs e altere o diretório nele:

    mkdir jobs
    cd jobs
    
  2. No mesmo diretório, crie um arquivo main.go para o código do job real. Copie as seguintes linhas de amostra:

    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
    }
    

    Os jobs do Cloud Run permitem que os usuários especifiquem o número de tarefas que o job precisa executar. Esse exemplo de código mostra como usar a variável de ambiente CLOUD_RUN_TASK_INDEX integrada. Cada tarefa representa uma cópia em execução do contêiner. As tarefas geralmente são executadas em paralelo. É útil usar várias tarefas se cada uma delas puder processar independentemente um subconjunto dos dados.

    Cada tarefa está ciente do índice armazenado na variável de ambiente CLOUD_RUN_TASK_INDEX. A variável de ambiente CLOUD_RUN_TASK_COUNT integrada contém o número de tarefas fornecidas no tempo de execução do job por meio do parâmetro --tasks.

    O código mostrado também mostra como repetir tarefas, usando o método integradoCLOUD_RUN_TASK_ATTEMPT que contém o número de vezes que essa tarefa foi repetida, começando em 0 para a primeira tentativa e aumentando em 1 a cada nova tentativa, até--max-retries de dados.

    O código também permite gerar falhas como uma maneira de testar novas tentativas e gerar registros de erro para que você possa ver como eles são.

  3. Crie um arquivo go.mod com o seguinte conteúdo:

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

Seu código está completo e pronto para ser empacotado em um contêiner.

Criar contêiner de jobs e enviar para o repositório

Importante: este guia de início rápido pressupõe que você tenha papéis de proprietário ou editor no projeto que está usando para este guia. Caso contrário, consulte as permissões de implantação do Cloud Run, as permissões do Cloud Build e as permissões do Artifact Registry.

Use um Buildpack para criar o contêiner:

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

Criar um job no Cloud Run

Para criar um job usando o contêiner que você acabou de criar, faça o seguinte:

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

em que PROJECT_ID é o ID do projeto e REGION é a região, por exemplo, us-central1. É possível mudar os vários parâmetros para os valores que você quer usar para fins de teste. O SLEEP_MS simula o trabalho, e FAIL_RATE faz com que X% das tarefas falhem. Assim, você pode testar o paralelismo e tentar novamente tarefas com falha.

Executar um job no Cloud Run

Para executar o job que você acabou de criar:

gcloud beta run jobs execute job-quickstart

Quando a região for solicitada, selecione a região que preferir, por exemplo, us-central1.

Testar localmente

Execute o job localmente:

docker run --rm -e FAIL_RATE=0.9 -e SLEEP_MS=1000 gcr.io/PROJECT_ID/logger-job
PROJECT_ID é o ID do projeto.

A seguir

Para mais informações sobre como criar um contêiner a partir do código-fonte e enviá-lo para um repositório, consulte: