Lorsque vous utilisez les composants du pipeline Google Cloud (GCPC), vous pouvez utiliser les fonctionnalités suivantes de Vertex AI et de Google Cloud pour sécuriser vos composants et vos artefacts.
Spécifier un compte de service pour un composant
Lorsque vous utilisez un composant, vous pouvez éventuellement spécifier un compte de service.
Votre composant utilise les autorisations de ce compte de service pour son lancement et ses actions.
Par exemple, vous pouvez utiliser le code suivant pour spécifier le compte de service pour un composant ModelDeploy :
model_deploy_op = ModelDeployOp(model=training_job_run_op.outputs["model"],
endpoint=endpoint_op.outputs["endpoint"],
automatic_resources_min_replica_count=1,
automatic_resources_max_replica_count=1,
service_account="SERVICE_ACCOUNT_ID@PROJECT_ID.iam.gserviceaccount.com")
Remplacez les éléments suivants :
- SERVICE_ACCOUNT_ID : ID du compte de service.
- PROJECT_ID : ID du projet
Découvrez comment utiliser un compte de service personnalisé et configurer un compte de service pour l'utiliser avec Vertex AI Pipelines.
Utiliser VPC Service Controls pour empêcher l'exfiltration de données
VPC Service Controls peut vous aider à limiter le risque d'exfiltration de données de Vertex AI Pipelines. Lorsque vous utilisez VPC Service Controls pour créer un périmètre de service, les ressources et les données créées par Vertex AI Pipelines et les composants du pipeline Google Cloud sont automatiquement protégées. Par exemple, lorsque vous utilisez VPC Service Controls pour protéger votre pipeline, les artefacts suivants ne peuvent pas quitter votre périmètre de service :
- Données d'entraînement pour un modèle AutoML
- Modèles que vous avez créés
- Résultats des requêtes de prédiction par lot
Apprenez-en plus sur VPC Service Controls avec Vertex AI.
Configurer l'appairage de réseaux VPC
Vous pouvez configurer des composants du pipeline Google Cloud pour effectuer l'appairage à un cloud privé virtuel en fournissant des paramètres supplémentaires. Par exemple, vous pouvez utiliser le code suivant pour spécifier un réseau VPC pour un composant EndpointCreate :
endpoint_create_op = EndpointCreateOp(
project="PROJECT_ID",
location="REGION",
display_name="endpoint-display-name",
network="NETWORK")
Remplacez les éléments suivants :
- PROJECT_ID : ID du projet
- REGION : région dans laquelle vous utilisez Vertex AI.
- NETWORK : réseau VPC, par exemple,
"projects/12345/global/networks/myVPC".
Apprenez-en plus sur l'appairage de réseaux VPC dans Vertex AI.
Utiliser des clés de chiffrement gérées par le client (CMEK)
Par défaut, Google Cloud chiffre automatiquement les données au repos à l'aide de clés de chiffrement gérées par Google. Si vous avez des exigences réglementaires ou de conformité spécifiques concernant les clés qui protègent vos données, vous pouvez utiliser des clés de chiffrement gérées par le client (CMEK) pour vos ressources. Avant de commencer à utiliser des clés de chiffrement gérées par le client, découvrez les avantages de CMEK sur Vertex AI et les ressources actuelles compatibles avec les CMEK.
Configurer le composant avec CMEK
Après avoir créé un trousseau et une clé dans Cloud Key Management Service et accordé des autorisations de chiffrement et de déchiffrement à Vertex AI pour cette clé, vous pouvez créer une clé en spécifiant votre clé comme paramètre de création. Par exemple, vous pouvez utiliser le code suivant pour spécifier une clé pour un composant ModelBatchPredict :
model_batch_predict_op = ModelBatchPredictOp(project="PROJECT_ID",
model=model_upload_op.outputs["model"],
encryption_spec_key_name="projects/PROJECT_ID/locations/LOCATION_ID/keyRings/KEY_RING_NAME/cryptoKeys/KEY_NAME")
Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet Google Cloud.
- LOCATION_ID : identifiant valide d'emplacement ou de région, par exemple
us-central1. - KEY_RING_NAME : nom du trousseau de clés pour votre CMEK. Pour en savoir plus sur les trousseaux de clés, consultez la page Ressources Cloud KMS.
- KEY_NAME : nom de la clé CMEK.
Remarque : Les composants Google Cloud autres que les composants Vertex AI peuvent nécessiter des autorisations supplémentaires. Par exemple, un composant BigQuery peut nécessiter une autorisation de chiffrement et de déchiffrement. De plus, l'emplacement de la clé CMEK doit être identique à celui du composant. Par exemple, si un composant BigQuery charge les données d'un ensemble de données basé dans l'emplacement multirégional "us", la clé CMEK doit également se trouver dans l'emplacement multirégional "us".
Utiliser ou produire des artefacts dans votre composant
Le SDK des composants du pipeline Google Cloud définit un ensemble de types d'artefacts de métadonnées de ML qui servent d'entrées et de sorties aux composants. Certains composants du pipeline Google Cloud utilisent ces artefacts en tant qu'entrées ou les produisent en sortie.
Cette page explique comment utiliser et produire ces artefacts.
Utiliser un artefact de ML
Utiliser un artefact dans un fichier YAML de composant
Les métadonnées de l'artefact peuvent servir d'entrée à un composant. Pour préparer un artefact en vue de son utilisation en entrée, vous devez l'extraire et le placer dans un fichier YAML de composant.
Par exemple, le composant ModelUploadOp génère un artefact google.VertexModel qui peut être utilisé par un composant ModelDeployOp. Utilisez le code suivant dans un fichier YAML de composant pour récupérer une ressource Vertex AI Model à partir des entrées (référence) :
"model": "',"{{$.inputs.artifacts['model'].metadata['resourceName']}}", '"'Pour obtenir le schéma complet des métadonnées de l'artefact, consultez le fichier artifact_types.py dans le dépôt GitHub de Kubeflow.
Utiliser un artefact dans un composant Python léger
from kfp.dsl import Artifact, Input
@dsl.component
def classification_model_eval_metrics(
project: str,
location: str, # "us-central1",
model: Input[Artifact],
) :
# Consumes the `resourceName` metadata
model_resource_path = model.metadata["resourceName"]
Pour obtenir un exemple d'utilisation des types d'artefacts Vertex ML Metadata, consultez la section Entraîner un modèle de classification à l'aide de données tabulaires et de Vertex AI AutoML.
Créer un artefact de ML
Les exemples de code suivants montrent comment créer un artefact Vertex ML Metadata qu'un composant GCPC peut accepter en tant qu'entrée.
Utiliser un nœud d'importation
L'exemple suivant crée un nœud d'importation qui enregistre une nouvelle entrée d'artefact dans Vertex ML Metadata. Le nœud d'importation utilise l'URI et les métadonnées de l'artefact en tant que primitives et les regroupe dans un artefact.
from google_cloud_pipeline_components import v1
from google_cloud_pipeline_components.types import artifact_types
from kfp.components import importer_node
from kfp import dsl
@dsl.pipeline(name=_PIPELINE_NAME)
def pipeline():
# Using importer and UnmanagedContainerModel artifact for model upload
# component.
importer_spec = importer_node.importer(
artifact_uri='gs://managed-pipeline-gcpc-e2e-test/automl-tabular/model',
artifact_class=artifact_types.UnmanagedContainerModel,
metadata={
'containerSpec': {
'imageUri':
'us-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server:prod'
}
})
# Consuming the UnmanagedContainerModel artifact for the previous step
model_upload_with_artifact_op = v1.model.ModelUploadOp(
project=_GCP_PROJECT_ID,
location=_GCP_REGION,
display_name=_MODEL_DISPLAY_NAME,
unmanaged_container_model=importer_spec.outputs['artifact'])
Utiliser des composants Python basés sur des fonctions
L'exemple suivant montre comment générer un artefact Vertex ML Metadata directement à partir d'un composant Python.
from google_cloud_pipeline_components import v1
from kfp.components import importer_node
from kfp import dsl
@dsl.component(
base_image='python:3.9',
packages_to_install=['google-cloud-aiplatform'],
)
# Note currently KFP SDK doesn't support outputting artifacts in `google` namespace.
# Use the base type dsl.Artifact instead.
def return_unmanaged_model(model: dsl.Output[dsl.Artifact]):
model.metadata['containerSpec'] = {
'imageUri':
'us-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server:prod'
}
model.uri = f'gs://automl-tabular-pipeline/automl-tabular/model'
@dsl.pipeline(name=_PIPELINE_NAME)
def pipeline():
unmanaged_model_op = return_unmanaged_model()
# Consuming the UnmanagedContainerModel artifact for the previous step
model_upload_with_artifact_op = v1.model.ModelUploadOp(
project=_GCP_PROJECT_ID,
location=_GCP_REGION,
display_name=_MODEL_DISPLAY_NAME,
unmanaged_container_model=unmanaged_model_op.outputs['model'])
Utiliser votre propre composant basé sur un conteneur
L'exemple suivant montre comment générer un artefact VertexBatchPredictionJob en tant que sortie d'un composant basé sur un conteneur à l'aide de la classe utilitaire artifact_types.py.
bp_job_artifact = VertexBatchPredictionJob(
'batchpredictionjob', vertex_uri_prefix + get_job_response.name,
get_job_response.name, get_job_response.output_info.bigquery_output_table,
get_job_response.output_info.bigquery_output_dataset,
get_job_response.output_info.gcs_output_directory)
output_artifacts = executor_input_json.get('outputs', {}).get('artifacts', {})
executor_output['artifacts'] = bp_job_artifact.to_executor_output_artifact(output_artifacts[bp_job_artifact.name])