Cette page a été traduite par l'API Cloud Translation.

Créer une sauvegarde et restaurer les données d'un notebook

Google Distributed Cloud (GDC) air-gapped vous permet de créer des sauvegardes et de restaurer des données à partir du répertoire personnel de vos instances JupyterLab.

Cette page explique comment créer et restaurer des sauvegardes des données de notebooks Vertex AI Workbench. Si vous ne connaissez pas Vertex AI, découvrez Vertex AI Workbench.

Avant de commencer

Pour obtenir les autorisations nécessaires pour copier les données restaurées, demandez à votre administrateur IAM de l'organisation de vous accorder le rôle Développeur de cluster utilisateur (user-cluster-developer).

Créer une sauvegarde et restaurer les données d'une instance JupyterLab

Définissez des applications protégées pour créer une sauvegarde du répertoire personnel d'une instance JupyterLab individuelle ou des répertoires personnels de toutes les instances JupyterLab d'un projet à la fois.

Créez une ressource personnalisée ProtectedApplication dans le cluster où vous souhaitez planifier les sauvegardes. Les plans de sauvegarde et de restauration utilisent des applications protégées pour sélectionner des ressources. Pour en savoir plus sur la création d'applications protégées, consultez Stratégies d'application protégée.

La ressource personnalisée ProtectedApplication contient les champs suivants :

Champ				Description
`resourceSelection`				La façon dont l'objet `ProtectedApplication` sélectionne les ressources pour les sauvegardes ou les restaurations.
	`type`			Méthode de sélection des ressources. Un type `Selector` indique que les ressources avec des libellés correspondants doivent être sélectionnées.
	`selector`			Règles de sélection. Ce champ contient les sous-champs suivants :
		`matchLabels`		Libellés utilisés par l'objet `ProtectedApplication` pour faire correspondre les ressources. Ce champ contient les sous-champs suivants :
			`app.kubernetes.io/part-of`	Nom d'une application de niveau supérieur dont celle-ci fait partie. Sélectionnez Vertex AI Workbench comme application de haut niveau pour les instances JupyterLab.
			`app.kubernetes.io/component`	Composant de l'architecture. Sélectionnez les ressources Vertex AI Workbench qui fournissent du stockage pour les instances JupyterLab.
			`app.kubernetes.io/instance`	Nom unique identifiant l'instance d'une application. Limitez le champ d'application pour sélectionner une instance JupyterLab. La valeur est identique au nom de l'instance JupyterLab dans la console GDC.

Utilisez la ressource personnalisée ProtectedApplication pour sélectionner le stockage d'une seule instance JupyterLab ou de toutes les instances JupyterLab d'un projet, comme dans les exemples suivants :

Sélectionnez le stockage d'une seule instance JupyterLab :

L'exemple suivant montre une ressource personnalisée ProtectedApplication qui sélectionne le stockage d'une instance JupyterLab nommée my-instance-name dans l'espace de noms my-project :

apiVersion: gkebackup.gke.io/v1
kind: ProtectedApplication
metadata:
  name: my-protected-application
  namespace: my-project
spec:
  resourceSelection:
    type: Selector
    selector:
      matchLabels:
        app.kubernetes.io/part-of: vtxwb
        app.kubernetes.io/component: storage
        app.kubernetes.io/instance: my-instance-name

Sélectionnez le stockage de toutes les instances JupyterLab :

L'exemple suivant montre une ressource personnalisée ProtectedApplication qui sélectionne le stockage pour toutes les instances JupyterLab de l'espace de noms my-project :
```
apiVersion: gkebackup.gke.io/v1
kind: ProtectedApplication
metadata:
  name: my-protected-application
  namespace: my-project
spec:
  resourceSelection:
    type: Selector
    selector:
      matchLabels:
        app.kubernetes.io/part-of: vtxwb
        app.kubernetes.io/component: storage
```
Cet exemple ne contient pas l'étiquette app.kubernetes.io/instance, car il sélectionne toutes les instances JupyterLab.

Pour créer une sauvegarde et restaurer des données à partir d'une instance JupyterLab, planifiez un ensemble de sauvegardes et planifiez un ensemble de restaurations à l'aide de la ressource personnalisée ProtectedApplication que vous avez définie.

Copier les données restaurées vers une nouvelle instance JupyterLab

Pour copier les données restaurées à partir de la ressource PersistentVolumeClaim d'une instance JupyterLab vers une nouvelle instance JupyterLab, procédez comme suit :

Remplissez les conditions préalables.
Créez un notebook JupyterLab associé à une instance JupyterLab pour copier les données restaurées.
Obtenez le nom du pod de l'instance JupyterLab dans laquelle vous avez créé le notebook :
```
kubectl get pods -l notebook-name=INSTANCE_NAME -n PROJECT_NAMESPACE
```
Remplacez les éléments suivants :
- INSTANCE_NAME : nom de l'instance JupyterLab que vous avez configurée.
- PROJECT_NAMESPACE : espace de noms du projet dans lequel vous avez créé l'instance JupyterLab.
Obtenez le nom de l'image sur laquelle l'instance JupyterLab s'exécute :
```
kubectl get pods POD_NAME -n PROJECT_NAMESPACE -o jsonpath="{.spec.containers[0].image}"
```
Remplacez les éléments suivants :
- POD_NAME : nom du pod de l'instance JupyterLab.
- PROJECT_NAMESPACE : espace de noms du projet dans lequel vous avez créé l'instance JupyterLab.
Recherchez le nom de la ressource PersistentVolumeClaim qui a été restaurée :
```
kubectl get pvc -l app.kubernetes.io/part-of=vtxwb,app.kubernetes.io/component=storage,app.kubernetes.io/instance=RESTORED_INSTANCE_NAME -n PROJECT_NAMESPACE
```
Remplacez les éléments suivants :
- RESTORED_INSTANCE_NAME : nom de l'instance JupyterLab que vous avez restaurée.
- PROJECT_NAMESPACE : espace de noms du projet dans lequel vous avez créé l'instance JupyterLab.

Créez un fichier YAML nommé vtxwb-data.yaml avec le contenu suivant :

apiVersion: v1
kind: Pod
metadata:
  name: vtxwb-data
  namespace: PROJECT_NAMESPACE
  labels:
    aiplatform.gdc.goog/service-type: workbench
spec:
  containers:
  - args:
    - sleep infinity
    command:
    - bash
    - -c
    image: IMAGE_NAME
    imagePullPolicy: IfNotPresent
    name: vtxwb-data
    resources:
      limits:
        cpu: "1"
        memory: 1Gi
      requests:
        cpu: "1"
        memory: 1Gi
    terminationMessagePath: /dev/termination-log
    terminationMessagePolicy: File
    volumeMounts:
    - mountPath: /home/jovyan
      name: restore-data
    workingDir: /home/jovyan
  volumes:
  - name: restore-data
    persistentVolumeClaim:
      claimName: RESTORED_PVC_NAME

Remplacez les éléments suivants :

PROJECT_NAMESPACE : espace de noms du projet dans lequel vous avez créé l'instance JupyterLab.
IMAGE_NAME : nom de l'image de conteneur sur laquelle l'instance JupyterLab est exécutée.
RESTORED_PVC_NAME : nom de la ressource PersistentVolumeClaim restaurée.

Créez un pod pour votre ressource PersistentVolumeClaim restaurée :
```
kubectl apply -f ./vtxwb-data --kubeconfig KUBECONFIG_PATH
```
Remplacez KUBECONFIG_PATH par le chemin d'accès au fichier kubeconfig dans le cluster.
Attendez que le pod vtxwb-data atteigne l'état RUNNING.
Copiez vos données restaurées dans une nouvelle instance JupyterLab :
```
kubectl cp PROJECT_NAMESPACE/vtxwb-data:/home/jovyan ./restore --kubeconfig KUBECONFIG_PATH

kubectl cp ./restore PROJECT_NAMESPACE/POD_NAME:/home/jovyan/restore --kubeconfig KUBECONFIG_PATH

rm ./restore
```
Remplacez les éléments suivants :
- PROJECT_NAMESPACE : espace de noms du projet dans lequel vous avez créé l'instance JupyterLab.
- KUBECONFIG_PATH : chemin d'accès au fichier kubeconfig dans le cluster.
- POD_NAME : nom du pod de l'instance JupyterLab.
Une fois les données copiées, vos données restaurées sont disponibles dans le répertoire /home/jovyan/restore.
Supprimez le pod que vous avez créé pour accéder à vos données restaurées :
```
kubectl delete pod vtxwb-data -n my-namespace` --kubeconfig KUBECONFIG_PATH
```
Remplacez KUBECONFIG_PATH par le chemin d'accès au fichier kubeconfig dans le cluster.