Pianifica l'esecuzione di un notebook

Questa pagina mostra come pianificare l'esecuzione di un notebook in Colab Enterprise.

Panoramica

Puoi programmare l'esecuzione di un blocco note immediatamente una volta o in base a una pianificazione ricorrente.

Quando pianifichi l'esecuzione del notebook, selezioni un modello di runtime. Colab Enterprise utilizza questo modello di runtime per creare il runtime che esegue il notebook.

Il runtime ha bisogno di autorizzazioni specifiche per eseguire il codice del notebook e accedere Google Cloud a servizi e API.

  • Se nella configurazione del modello di runtime sono attive le credenziali dell'utente finale, il runtime utilizza le autorizzazioni associate alle tue credenziali utente.

  • Se le credenziali dell'utente finale non sono abilitate, devi specificare un account di servizio quando pianifichi l'esecuzione del notebook. Colab Enterprise utilizza le credenziali di questo account di servizio per eseguire il notebook.

Per maggiori informazioni, vedi Ruoli richiesti per l'esecuzione del notebook.

Al termine dell'esecuzione del notebook da parte di Colab Enterprise, i risultati vengono archiviati in un bucket Cloud Storage condivisibile.

Limitazioni

I runtime di Colab Enterprise utilizzano la quota di Compute Engine. Consulta la pagina delle quote di allocazione di Compute Engine.

Prima di iniziare

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI, Dataform, and Compute Engine APIs.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI, Dataform, and Compute Engine APIs.

    Enable the APIs

  8. Ruoli obbligatori per la pianificazione dell'esecuzione del notebook

    Per ottenere le autorizzazioni necessarie per pianificare l'esecuzione di un notebook in Colab Enterprise, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

    Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

    Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

    Ruoli richiesti per l'esecuzione del notebook

    L'entità che esegue il notebook necessita di autorizzazioni specifiche. L'entità è il tuo account utente o un account di servizio che specifichi, come descritto nella panoramica.

    Per ottenere le autorizzazioni necessarie per eseguire un notebook in Colab Enterprise, chiedi all'amministratore di concederti i seguenti ruoli IAM:

    Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

    Questi ruoli predefiniti contengono le autorizzazioni necessarie per eseguire un notebook in Colab Enterprise. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

    Autorizzazioni obbligatorie

    Per eseguire un notebook in Colab Enterprise sono necessarie le seguenti autorizzazioni:

    • dataform.locations.list sul notebook
    • dataform.repositories.computeAccessTokenStatus sul notebook
    • dataform.repositories.fetchHistory sul notebook
    • dataform.repositories.fetchRemoteBranches sul notebook
    • dataform.repositories.get sul notebook
    • dataform.repositories.getIamPolicy sul notebook
    • dataform.repositories.list sul notebook
    • dataform.repositories.queryDirectoryContents sul notebook
    • dataform.repositories.readFile sul notebook
    • logging.logEntries.create sul progetto
    • logging.logEntries.route sul progetto
    • monitoring.metricDescriptors.create sul progetto
    • monitoring.metricDescriptors.get sul progetto
    • monitoring.metricDescriptors.list sul progetto
    • monitoring.monitoredResourceDescriptors.get sul progetto
    • monitoring.monitoredResourceDescriptors.list sul progetto
    • monitoring.timeSeries.create sul progetto
    • resourcemanager.projects.get sul progetto
    • resourcemanager.projects.list sul progetto
    • storage.buckets.get sul notebook
    • storage.managedFolders.create sul notebook
    • storage.managedFolders.delete sul notebook
    • storage.managedFolders.get sul notebook
    • storage.managedFolders.list sul notebook
    • storage.multipartUploads.abort sul notebook
    • storage.multipartUploads.create sul notebook
    • storage.multipartUploads.list sul notebook
    • storage.multipartUploads.listParts sul notebook
    • storage.objects.create sul notebook
    • storage.objects.delete sul notebook
    • storage.objects.get sul notebook
    • storage.objects.list sul notebook
    • storage.objects.restore sul notebook
    • storage.objects.setRetention sul notebook

    Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

    Esegui un notebook una volta

    Per eseguire un notebook una sola volta, puoi utilizzare la console Google Cloud , Google Cloud CLI, la libreria client Python di Vertex AI o Terraform.

    Console

    1. Nella console Google Cloud , vai alla pagina I miei blocchi note di Colab Enterprise.

      Vai a I miei notebook

    2. Nel menu Regione, seleziona la regione che contiene il notebook.

    3. Accanto a un blocco note, fai clic sul menu Azioni del blocco note e seleziona Pianifica.

    4. Nel campo Nome pianificazione, inserisci un nome per la pianificazione.

    5. Fai clic sull'elenco Modello di runtime e seleziona un modello di runtime. Il modello di runtime determina le specifiche del runtime che esegue il notebook.

    6. In Pianificazione esecuzione, seleziona Una tantum per eseguire il notebook non appena lo invii.

    7. Accanto al campo Posizione di output di Cloud Storage, fai clic su Sfoglia per aprire la finestra di dialogo Seleziona cartella.

    8. Seleziona un bucket Cloud Storage. In alternativa, per creare un bucket, fai clic su  Crea nuovo bucket e completa la finestra di dialogo.

    9. Se hai selezionato un modello di runtime senza credenziali dell'utente finale abilitate, la finestra di dialogo include un campo Service account. Nel campo Account di servizio, inserisci l'indirizzo email di un account di servizio.

    10. Fai clic su Invia.

      L'esecuzione del notebook inizia immediatamente.

    gcloud

    Prima di utilizzare i dati dei comandi riportati di seguito, apporta le seguenti sostituzioni:

    • DISPLAY_NAME: il nome visualizzato per l'esecuzione del notebook.
    • NOTEBOOK_RUNTIME_TEMPLATE: il modello di runtime del notebook che specifica la configurazione di calcolo del runtime.
    • NOTEBOOK_URI: l'URI Cloud Storage del notebook da eseguire.
    • OUTPUT_URI: la posizione Cloud Storage in cui vuoi archiviare i risultati.
    • USER_EMAIL: l'indirizzo email dell'account utente che specifica l'accesso dell'esecuzione del notebook alle risorse Google Cloud .
    • PROJECT_ID: il tuo ID progetto.
    • REGION: la regione in cui verrà eseguito il notebook.

    Esegui questo comando:

    Linux, macOS o Cloud Shell

    gcloud colab executions create --display-name="DISPLAY_NAME" \
        --notebook-runtime-template=NOTEBOOK_RUNTIME_TEMPLATE \
        --gcs-notebook-uri=NOTEBOOK_URI \
        --gcs-output-uri=OUTPUT_URI \
        --user-email=USER_EMAIL \
        --project=PROJECT_ID \
        --region=REGION

    Windows (PowerShell)

    gcloud colab executions create --display-name="DISPLAY_NAME" `
        --notebook-runtime-template=NOTEBOOK_RUNTIME_TEMPLATE `
        --gcs-notebook-uri=NOTEBOOK_URI `
        --gcs-output-uri=OUTPUT_URI `
        --user-email=USER_EMAIL `
        --project=PROJECT_ID `
        --region=REGION

    Windows (cmd.exe)

    gcloud colab executions create --display-name="DISPLAY_NAME" ^
        --notebook-runtime-template=NOTEBOOK_RUNTIME_TEMPLATE ^
        --gcs-notebook-uri=NOTEBOOK_URI ^
        --gcs-output-uri=OUTPUT_URI ^
        --user-email=USER_EMAIL ^
        --project=PROJECT_ID ^
        --region=REGION

    Per saperne di più sulla gestione delle esecuzioni dei notebook Colab Enterprise dalla riga di comando, consulta la documentazione di gcloud CLI.

    Python

    Prima di provare questo esempio, installa l'SDK Vertex AI per Python. La libreria client Python di Vertex AI viene installata quando installi l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI SDK for Python.

    Per eseguire il seguente esempio di codice, devi disporre dell'ID repository Dataform del notebook. Per ottenere l'ID repository del notebook, puoi utilizzare il metodo list_repositories di Dataform.

    from google.cloud import aiplatform_v1
    
    PROJECT_ID = "my-project"
    LOCATION = "us-central1"
    REPOSITORY_ID = "b223577f-a3fb-482c-a22c-0658c6602598"
    TEMPLATE_ID = "6524523989455339520"
    
    API_ENDPOINT = f"{LOCATION}-aiplatform.googleapis.com"
    PARENT = f"projects/{PROJECT_ID}/locations/{LOCATION}"
    
    notebook_service_client = aiplatform_v1.NotebookServiceClient(client_options = {
        "api_endpoint": API_ENDPOINT,
    })
    
    operation = notebook_service_client.create_notebook_execution_job(parent=PARENT, notebook_execution_job={
        "display_name": "my-execution-job",
    
        # Specify a NotebookRuntimeTemplate to source compute configuration from
        "notebook_runtime_template_resource_name": f"projects/{PROJECT_ID}/locations/{LOCATION}/notebookRuntimeTemplates/{TEMPLATE_ID}",
    
        # Specify a Colab Enterprise notebook to run
        "dataform_repository_source": {
            "dataform_repository_resource_name": f"projects/{PROJECT_ID}/locations/{LOCATION}/repositories/{REPOSITORY_ID}",
        },
    
        # Specify a Cloud Storage bucket to store output artifacts
        "gcs_output_uri": "gs://my-bucket/",
    
        # Specify the identity that runs the notebook
        "execution_user": "{EMAIL}",
    
        # Run as the service account instead
        # "service_account": "my-service-account",
    })
    print("Waiting for operation to complete...")
    result = operation.result()

    Terraform

    Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base. Per saperne di più, consulta la documentazione di riferimento del fornitore Terraform.

    L'esempio seguente utilizza la risorsa Terraform google_colab_notebook_execution per eseguire un notebook Colab Enterprise.

    resource "google_colab_runtime_template" "my_runtime_template" {
      provider = google-beta
      name = "{{index $.Vars "runtime_template_name"}}"
      display_name = "Runtime template"
      location = "us-central1"
    
      machine_spec {
        machine_type     = "e2-standard-4"
      }
    
      network_spec {
        enable_internet_access = true
      }
    }
    
    resource "google_storage_bucket" "output_bucket" {
      provider = google-beta
      name          = "{{index $.Vars "bucket"}}"
      location      = "US"
      force_destroy = true
      uniform_bucket_level_access = true
    }
    
    resource "google_storage_bucket_object" "notebook" {
      provider = google-beta
      name   = "hello_world.ipynb"
      bucket = google_storage_bucket.output_bucket.name
      content = <<EOF
        {
          "cells": [
            {
              "cell_type": "code",
              "execution_count": null,
              "metadata": {},
              "outputs": [],
              "source": [
                "print(\"Hello, World!\")"
              ]
            }
          ],
          "metadata": {
            "kernelspec": {
              "display_name": "Python 3",
              "language": "python",
              "name": "python3"
            },
            "language_info": {
              "codemirror_mode": {
                "name": "ipython",
                "version": 3
              },
              "file_extension": ".py",
              "mimetype": "text/x-python",
              "name": "python",
              "nbconvert_exporter": "python",
              "pygments_lexer": "ipython3",
              "version": "3.8.5"
            }
          },
          "nbformat": 4,
          "nbformat_minor": 4
        }
        EOF
    }
    
    resource "google_colab_notebook_execution" "{{$.PrimaryResourceId}}" {
      provider = google-beta
      notebook_execution_job_id = "{{index $.Vars "notebook_execution_job_id"}}"
      display_name = "Notebook execution full"
      location = "us-central1"
    
      execution_timeout = "86400s"
      gcs_notebook_source {
      uri = "gs://${google_storage_bucket_object.notebook.bucket}/${google_storage_bucket_object.notebook.name}"
      generation = google_storage_bucket_object.notebook.generation
      }
    
      service_account = "{{index $.TestEnvVars "service_account"}}"
    
      gcs_output_uri = "gs://${google_storage_bucket.output_bucket.name}"
      notebook_runtime_template_resource_name = "projects/${google_colab_runtime_template.my_runtime_template.project}/locations/${google_colab_runtime_template.my_runtime_template.location}/notebookRuntimeTemplates/${google_colab_runtime_template.my_runtime_template.name}"
    
      depends_on = [
        google_storage_bucket_object.notebook,
        google_storage_bucket.output_bucket,
        google_colab_runtime_template.my_runtime_template,
      ]
    
    }
    

    Puoi visualizzare i risultati delle esecuzioni del notebook completate nella pagina Esecuzioni.

    Pianifica l'esecuzione di un notebook

    Per pianificare l'esecuzione di un notebook, puoi utilizzare la console Google Cloud , gcloud CLI, la libreria client Python di Vertex AI o Terraform.

    Console

    1. Nella console Google Cloud , vai alla pagina I miei blocchi note di Colab Enterprise.

      Vai a I miei notebook

    2. Nel menu Regione, seleziona la regione che contiene il notebook.

    3. Accanto a un blocco note, fai clic sul menu Azioni del blocco note e seleziona Pianifica.

    4. Nel campo Nome pianificazione, inserisci un nome per la pianificazione.

    5. Fai clic sull'elenco Modello di runtime e seleziona un modello di runtime. Il modello di runtime determina le specifiche del runtime che esegue il notebook.

    6. Nella sezione Pianificazione esecuzione, seleziona Ricorrente per pianificare l'esecuzione del notebook per un intervallo di tempo specifico.

    7. Completa la finestra di dialogo di programmazione.

    8. Accanto al campo Posizione di output di Cloud Storage, fai clic su Sfoglia per aprire la finestra di dialogo Seleziona cartella.

    9. Seleziona un bucket Cloud Storage. In alternativa, per creare un bucket, fai clic su  Crea nuovo bucket e completa la finestra di dialogo.

    10. Se hai selezionato un modello di runtime senza credenziali dell'utente finale abilitate, la finestra di dialogo include un campo Service account. Nel campo Account di servizio, inserisci l'indirizzo email di un account di servizio.

    11. Fai clic su Invia.

      Le esecuzioni pianificate dei notebook vengono avviate automaticamente in base alla pianificazione impostata.

    gcloud

    Prima di utilizzare i dati dei comandi riportati di seguito, apporta le seguenti sostituzioni:

    • DISPLAY_NAME: il nome visualizzato della pianificazione.
    • CRON_SCHEDULE: la pianificazione che hai impostato, in formato unix-cron. Ad esempio, 00 19 * * MON significa ogni lunedì alle ore 19:00 Greenwich Mean Time (GMT).
    • NOTEBOOK_RUN_NAME: il nome visualizzato per le esecuzioni del notebook generate da questa pianificazione.
    • NOTEBOOK_RUNTIME_TEMPLATE: il modello di runtime del notebook che specifica la configurazione di calcolo del runtime.
    • NOTEBOOK_URI: l'URI Cloud Storage del notebook da eseguire.
    • OUTPUT_URI: la posizione Cloud Storage in cui vuoi archiviare i risultati.
    • USER_EMAIL: l'indirizzo email dell'account utente che specifica l'accesso dell'esecuzione del notebook alle risorse Google Cloud .
    • PROJECT_ID: il tuo ID progetto.
    • REGION: la regione in cui verrà eseguita la pianificazione.

    Esegui questo comando:

    Linux, macOS o Cloud Shell

    gcloud colab schedules create --display-name="DISPLAY_NAME" \
        --cron-schedule=CRON_SCHEDULE \
        --execution-display-name=NOTEBOOK_RUN_NAME \
        --notebook-runtime-template=NOTEBOOK_RUNTIME_TEMPLATE \
        --gcs-notebook-uri=NOTEBOOK_URI \
        --gcs-output-uri=OUTPUT_URI \
        --user-email=USER_EMAIL \
        --project=PROJECT_ID \
        --region=REGION

    Windows (PowerShell)

    gcloud colab schedules create --display-name="DISPLAY_NAME" `
        --cron-schedule=CRON_SCHEDULE `
        --execution-display-name=NOTEBOOK_RUN_NAME `
        --notebook-runtime-template=NOTEBOOK_RUNTIME_TEMPLATE `
        --gcs-notebook-uri=NOTEBOOK_URI `
        --gcs-output-uri=OUTPUT_URI `
        --user-email=USER_EMAIL `
        --project=PROJECT_ID `
        --region=REGION

    Windows (cmd.exe)

    gcloud colab schedules create --display-name="DISPLAY_NAME" ^
        --cron-schedule=CRON_SCHEDULE ^
        --execution-display-name=NOTEBOOK_RUN_NAME ^
        --notebook-runtime-template=NOTEBOOK_RUNTIME_TEMPLATE ^
        --gcs-notebook-uri=NOTEBOOK_URI ^
        --gcs-output-uri=OUTPUT_URI ^
        --user-email=USER_EMAIL ^
        --project=PROJECT_ID ^
        --region=REGION

    Per saperne di più sulla creazione di pianificazioni dei notebook Colab Enterprise dalla riga di comando, consulta la documentazione di gcloud CLI.

    Python

    Prima di provare questo esempio, installa l'SDK Vertex AI per Python. La libreria client Python di Vertex AI viene installata quando installi l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI SDK for Python.

    Per eseguire il seguente esempio di codice, devi disporre dell'ID repository Dataform del notebook. Per ottenere l'ID repository del notebook, puoi utilizzare il metodo list_repositories di Dataform.

    from google.cloud import aiplatform_v1
    
    PROJECT_ID = "my-project"
    LOCATION = "us-central1"
    REPOSITORY_ID = "b223577f-a3fb-482c-a22c-0658c6602598"
    TEMPLATE_ID = "6524523989455339520"
    
    API_ENDPOINT = f"{LOCATION}-aiplatform.googleapis.com"
    PARENT = f"projects/{PROJECT_ID}/locations/{LOCATION}"
    
    schedules_service_client = aiplatform_v1.ScheduleServiceClient(client_options = {
        "api_endpoint": API_ENDPOINT,
    })
    
    schedule = schedules_service_client.create_schedule(parent=PARENT, schedule={
        "display_name": "my-notebook-schedule",
    
        # Time specification. TZ is optional.
        # cron = "* * * * *" to run it in the next minute.
        "cron": "TZ=America/Los_Angeles * * * * *",
    
        # How many runs the schedule will trigger before it becomes COMPLETED.
        # A Schedule in COMPLETED state will not trigger any more runs.
        "max_run_count": 1,
        "max_concurrent_run_count": 1,
    
        "create_notebook_execution_job_request": {
          "parent": PARENT,
          "notebook_execution_job": {
            "display_name": "my-execution-job",
    
            # Specify a NotebookRuntimeTemplate to source compute configuration from
            "notebook_runtime_template_resource_name": f"projects/{PROJECT_ID}/locations/{LOCATION}/notebookRuntimeTemplates/{TEMPLATE_ID}",
    
            # Specify a Colab Enterprise notebook to run
            "dataform_repository_source": {
                "dataform_repository_resource_name": f"projects/{PROJECT_ID}/locations/{LOCATION}/repositories/{REPOSITORY_ID}",
            },
    
            # Specify a Cloud Storage bucket to store output artifacts
            "gcs_output_uri": "gs://my-bucket/",
    
    
            # Specify the identity that runs the notebook
            "execution_user": "{EMAIL}",
    
            # Run as the service account instead
            # "service_account": "my-service-account",
        }
      }
    })

    Terraform

    Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base. Per saperne di più, consulta la documentazione di riferimento del fornitore Terraform.

    Il seguente esempio utilizza la risorsa Terraform google_colab_schedule per pianificare l'esecuzione di un notebook Colab Enterprise.

    resource "google_colab_runtime_template" "my_runtime_template" {
      provider = google-beta
      name = "{{index $.Vars "runtime_template_name"}}"
      display_name = "Runtime template"
      location = "us-central1"
    
      machine_spec {
        machine_type     = "e2-standard-4"
      }
    
      network_spec {
        enable_internet_access = true
      }
    }
    
    resource "google_storage_bucket" "output_bucket" {
      provider = google-beta
      name          = "{{index $.Vars "bucket"}}"
      location      = "US"
      force_destroy = true
      uniform_bucket_level_access = true
    }
    
    resource "google_secret_manager_secret" "secret" {
      provider = google-beta
      secret_id = "{{index $.Vars "secret"}}"
      replication {
        auto {}
      }
    }
    
    resource "google_secret_manager_secret_version" "secret_version" {
      provider = google-beta
      secret = google_secret_manager_secret.secret.id
      secret_data = "secret-data"
    }
    
    resource "google_dataform_repository" "dataform_repository" {
      provider = google-beta
      name = "{{index $.Vars "dataform_repository"}}"
      display_name = "dataform_repository"
      npmrc_environment_variables_secret_version = google_secret_manager_secret_version.secret_version.id
      kms_key_name = "{{index $.Vars "key_name"}}"
    
      labels = {
        label_foo1 = "label-bar1"
      }
    
      git_remote_settings {
          url = "https://github.com/OWNER/REPOSITORY.git"
          default_branch = "main"
          authentication_token_secret_version = google_secret_manager_secret_version.secret_version.id
      }
    
      workspace_compilation_overrides {
        default_database = "database"
        schema_suffix = "_suffix"
        table_prefix = "prefix_"
      }
    
    }
    
    resource "google_colab_schedule" "{{$.PrimaryResourceId}}" {
      provider = google-beta
      display_name = "{{index $.Vars "display_name"}}"
      location = "{{index $.TestEnvVars "location"}}"
      allow_queueing = true
      max_concurrent_run_count = 2
      cron = "TZ=America/Los_Angeles * * * * *"
      max_run_count = 5
      start_time = "{{index $.Vars "start_time"}}"
      end_time = "{{index $.Vars "end_time"}}"
    
      desired_state = "ACTIVE"
    
      create_notebook_execution_job_request {
        notebook_execution_job {
          display_name = "Notebook execution"
          execution_timeout = "86400s"
    
          dataform_repository_source {
            commit_sha = "randomsha123"
            dataform_repository_resource_name = "projects/{{index $.TestEnvVars "project_id"}}/locations/{{index $.TestEnvVars "location"}}/repositories/${google_dataform_repository.dataform_repository.name}"
          }
    
          notebook_runtime_template_resource_name = "projects/${google_colab_runtime_template.my_runtime_template.project}/locations/${google_colab_runtime_template.my_runtime_template.location}/notebookRuntimeTemplates/${google_colab_runtime_template.my_runtime_template.name}"
    
          gcs_output_uri = "gs://${google_storage_bucket.output_bucket.name}"
          service_account = "{{index $.TestEnvVars "service_account"}}"
        }
      }
    
      depends_on = [
        google_colab_runtime_template.my_runtime_template,
        google_storage_bucket.output_bucket,
        google_secret_manager_secret_version.secret_version,
        google_dataform_repository.dataform_repository,
      ]
    }
    

    Nella console Google Cloud , puoi visualizzare le pianificazioni nella pagina Pianificazioni. Puoi visualizzare i risultati delle esecuzioni del notebook completate nella pagina Esecuzioni.

    Visualizza risultati

    Per visualizzare i risultati dell'esecuzione del notebook, puoi utilizzare la console Google Cloud , gcloud CLI o la libreria client Python di Vertex AI.

    Console

    1. Nella console Google Cloud , vai alla pagina Esecuzioni di Colab Enterprise.

      Vai a Esecuzioni

    2. Accanto all'esecuzione del blocco note per cui vuoi visualizzare i risultati, fai clic su Visualizza risultato.

      Colab Enterprise apre il risultato dell'esecuzione del notebook in una nuova scheda.

    3. Per visualizzare il risultato, fai clic sulla scheda.

    gcloud

    Prima di utilizzare i dati dei comandi riportati di seguito, apporta le seguenti sostituzioni:

    • PROJECT_ID: il tuo ID progetto.
    • REGION: la regione in cui si trovano i risultati dell'esecuzione del notebook.
    • SCHEDULE_NAME: il nome della pianificazione per cui visualizzare i risultati. Per visualizzare i risultati di tutte le pianificazioni, ometti il flag --filter.

    Esegui questo comando:

    Linux, macOS o Cloud Shell

    gcloud colab executions list --project=PROJECT_ID \
        --region=REGION \
        --filter="scheduleResourceName:SCHEDULE_NAME"

    Windows (PowerShell)

    gcloud colab executions list --project=PROJECT_ID `
        --region=REGION `
        --filter="scheduleResourceName:SCHEDULE_NAME"

    Windows (cmd.exe)

    gcloud colab executions list --project=PROJECT_ID ^
        --region=REGION ^
        --filter="scheduleResourceName:SCHEDULE_NAME"

    Per saperne di più sull'elenco delle esecuzioni dei notebook Colab Enterprise dalla riga di comando, consulta la documentazione di gcloud CLI.

    Python

    Prima di provare questo esempio, installa l'SDK Vertex AI per Python. La libreria client Python di Vertex AI viene installata quando installi l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI SDK for Python.

    Per eseguire il seguente esempio di codice, devi disporre dell'ID repository Dataform del notebook. Per ottenere l'ID repository del notebook, puoi utilizzare il metodo list_repositories di Dataform.

    from google.cloud import aiplatform_v1
    
    PROJECT_ID = "my-project"
    LOCATION = "us-central1"
    
    API_ENDPOINT = f"{LOCATION}-aiplatform.googleapis.com"
    PARENT = f"projects/{PROJECT_ID}/locations/{LOCATION}"
    
    notebook_service_client = aiplatform_v1.NotebookServiceClient(client_options = {
        "api_endpoint": API_ENDPOINT,
    })
    
    notebook_execution_jobs = notebook_service_client.list_notebook_execution_jobs(parent=PARENT)
    notebook_execution_jobs

    Eliminare i risultati

    Per eliminare un risultato da una delle esecuzioni del notebook, puoi utilizzare la console Google Cloud o gcloud CLI.

    Console

    1. Nella console Google Cloud , vai alla pagina Esecuzioni di Colab Enterprise.

      Vai a Esecuzioni

    2. Seleziona l'esecuzione del blocco note per cui vuoi eliminare il risultato.

    3. Fai clic su  Elimina.

    4. Per confermare l'eliminazione, fai clic su Conferma.

    gcloud

    Prima di utilizzare i dati dei comandi riportati di seguito, apporta le seguenti sostituzioni:

    • NOTEBOOK_RUN_ID: l'ID dell'esecuzione del notebook che vuoi eliminare.
    • PROJECT_ID: il tuo ID progetto.
    • REGION: la regione in cui si trova l'esecuzione del notebook.

    Esegui questo comando:

    Linux, macOS o Cloud Shell

    gcloud colab executions delete NOTEBOOK_RUN_ID \
        --project=PROJECT_ID \
        --region=REGION

    Windows (PowerShell)

    gcloud colab executions delete NOTEBOOK_RUN_ID `
        --project=PROJECT_ID `
        --region=REGION

    Windows (cmd.exe)

    gcloud colab executions delete NOTEBOOK_RUN_ID ^
        --project=PROJECT_ID ^
        --region=REGION

    Per saperne di più sull'eliminazione delle esecuzioni dei notebook Colab Enterprise dalla riga di comando, consulta la documentazione di gcloud CLI.

    Condividere i risultati dell'esecuzione di un notebook

    Puoi condividere i risultati dell'esecuzione del notebook fornendo l'accesso al bucket Cloud Storage che contiene l'esecuzione del notebook. La concessione di questo accesso garantisce agli utenti anche l'accesso a qualsiasi altra risorsa nello stesso bucket Cloud Storage (vedi Considerazioni sulla sicurezza).

    Per maggiori informazioni, consulta la pagina Condivisione e collaborazione di Cloud Storage.

    Considerazioni sulla sicurezza

    I risultati dell'esecuzione del blocco note vengono archiviati come file del blocco note (IPYNB) in un bucket Cloud Storage. Tieni presente quanto segue quando concedi l'accesso a questo bucket:

    • Chiunque abbia accesso al bucket può visualizzare il codice del file del notebook e i risultati dell'esecuzione del notebook.

    • Chiunque abbia la possibilità di modificare i contenuti del bucket può modificare i contenuti del file del blocco note.

    Quando la pianificazione è configurata per utilizzare le credenziali personali, solo l'utente specificato può modificare o attivare la pianificazione.

    Quando la pianificazione è configurata per utilizzare un account di servizio, solo gli utenti con l'autorizzazione iam.serviceAccounts.actAs sul account di servizio possono modificare la pianificazione o attivarla.

    Visualizzare i dettagli della pianificazione

    Puoi visualizzare informazioni su una pianificazione, tra cui:

    • Il bucket Cloud Storage in cui la pianificazione archivia i risultati.
    • L'ora di inizio e di fine.
    • La frequenza.

    Per visualizzare i dettagli della pianificazione, puoi utilizzare la console Google Cloud o gcloud CLI.

    Console

    1. Nella console Google Cloud , vai alla pagina Pianificazioni di Colab Enterprise.

      Vai a Pianificazioni

    2. Fai clic sul nome di una programmazione.

      Viene visualizzata la pagina Dettagli pianificazione.

    3. Per tornare alla pagina Pianificazioni, fai clic su  Torna alla pagina precedente.

    gcloud

    Prima di utilizzare i dati dei comandi riportati di seguito, apporta le seguenti sostituzioni:

    • SCHEDULE: il tuo ID pianificazione.
    • PROJECT_ID: il tuo ID progetto.
    • REGION: la regione in cui si trova la pianificazione.

    Esegui questo comando:

    Linux, macOS o Cloud Shell

    gcloud colab schedules describe SCHEDULE \
        --project=PROJECT_ID \
        --region=REGION

    Windows (PowerShell)

    gcloud colab schedules describe SCHEDULE `
        --project=PROJECT_ID `
        --region=REGION

    Windows (cmd.exe)

    gcloud colab schedules describe SCHEDULE ^
        --project=PROJECT_ID ^
        --region=REGION

    Per saperne di più sulla visualizzazione delle pianificazioni di Colab Enterprise dalla riga di comando, consulta la documentazione di gcloud CLI.

    Mettere in pausa, riprendere o eliminare una pianificazione

    Per mettere in pausa, riprendere o eliminare una pianificazione, puoi utilizzare la console Google Cloud , gcloud CLI o Terraform.

    Console

    1. Nella console Google Cloud , vai alla pagina Pianificazioni di Colab Enterprise.

      Vai a Pianificazioni

    2. Seleziona una pianificazione.

    3. Fai clic su  Pausa,  Riprendi, o  Elimina.

    gcloud

    Prima di utilizzare i dati dei comandi riportati di seguito, apporta le seguenti sostituzioni:

    • ACTION: uno tra pause, resume o delete.
    • SCHEDULE_ID: il tuo ID pianificazione.
    • PROJECT_ID: il tuo ID progetto.
    • REGION: la regione in cui si trova la pianificazione.

    Esegui questo comando:

    Linux, macOS o Cloud Shell

    gcloud colab schedules ACTION SCHEDULE_ID \
        --project=PROJECT_ID \
        --region=REGION

    Windows (PowerShell)

    gcloud colab schedules ACTION SCHEDULE_ID `
        --project=PROJECT_ID `
        --region=REGION

    Windows (cmd.exe)

    gcloud colab schedules ACTION SCHEDULE_ID ^
        --project=PROJECT_ID ^
        --region=REGION

    Per saperne di più sulla gestione delle pianificazioni di Colab Enterprise dalla riga di comando, consulta la documentazione di gcloud CLI.

    Terraform

    Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base. Per saperne di più, consulta la documentazione di riferimento del fornitore Terraform.

    L'esempio seguente utilizza la risorsa Terraform google_colab_schedule per mettere in pausa o riprendere una pianificazione.

    Per utilizzare questo esempio, modifica il valore di desired_state come descritto di seguito:

    • PAUSED per mettere in pausa la pianificazione
    • ACTIVE per riprendere la programmazione
    resource "google_colab_runtime_template" "my_runtime_template" {
      name = "{{index $.Vars "runtime_template_name"}}"
      display_name = "Runtime template"
      location = "us-central1"
    
      machine_spec {
        machine_type     = "e2-standard-4"
      }
    
      network_spec {
        enable_internet_access = true
      }
    }
    
    resource "google_storage_bucket" "output_bucket" {
      name          = "{{index $.Vars "bucket"}}"
      location      = "US"
      force_destroy = true
      uniform_bucket_level_access = true
    }
    
    resource "google_storage_bucket_object" "notebook" {
      name   = "hello_world.ipynb"
      bucket = google_storage_bucket.output_bucket.name
      content = <<EOF
        {
          "cells": [
            {
              "cell_type": "code",
              "execution_count": null,
              "metadata": {},
              "outputs": [],
              "source": [
                "print(\"Hello, World!\")"
              ]
            }
          ],
          "metadata": {
            "kernelspec": {
              "display_name": "Python 3",
              "language": "python",
              "name": "python3"
            },
            "language_info": {
              "codemirror_mode": {
                "name": "ipython",
                "version": 3
              },
              "file_extension": ".py",
              "mimetype": "text/x-python",
              "name": "python",
              "nbconvert_exporter": "python",
              "pygments_lexer": "ipython3",
              "version": "3.8.5"
            }
          },
          "nbformat": 4,
          "nbformat_minor": 4
        }
        EOF
    }
    
    resource "google_colab_schedule" "{{$.PrimaryResourceId}}" {
      display_name = "{{index $.Vars "display_name"}}"
      location = "{{index $.TestEnvVars "location"}}"
      max_concurrent_run_count = 2
      cron = "TZ=America/Los_Angeles * * * * *"
    
      desired_state = "PAUSED"
    
      create_notebook_execution_job_request {
        notebook_execution_job {
          display_name = "Notebook execution"
          gcs_notebook_source {
            uri = "gs://${google_storage_bucket_object.notebook.bucket}/${google_storage_bucket_object.notebook.name}"
            generation = google_storage_bucket_object.notebook.generation
          }
    
          notebook_runtime_template_resource_name = "projects/${google_colab_runtime_template.my_runtime_template.project}/locations/${google_colab_runtime_template.my_runtime_template.location}/notebookRuntimeTemplates/${google_colab_runtime_template.my_runtime_template.name}"
          gcs_output_uri = "gs://${google_storage_bucket.output_bucket.name}"
          service_account = "{{index $.TestEnvVars "service_account"}}"
          }
      }
    
      depends_on = [
        google_colab_runtime_template.my_runtime_template,
        google_storage_bucket.output_bucket,
      ]
    }
    

    Passaggi successivi