Fournisseur Databricks du kit CDK Terraform

Article
08/29/2024

Notes

Cet article traite du Kit de développement cloud pour Terraform (CDKTF), développé par un tiers. Pour contacter le fournisseur, consultez la page Communauté Terraform.

Cet article vous montre comment utiliser Python avec le fournisseur Databricks du kit CDK Terraform et le Kit de développement cloud pour Terraform (CDKTF). Le kit CDKTF est une plateforme d’infrastructure en tant que code (IaC) tierce qui vous permet de créer, déployer et gérer des ressources Azure Databricks à l’aide de langages de programmation, d’outils et de pratiques d’ingénierie familiers. Bien que cet article vous montre comment utiliser Python, le kit CDKTF prend en charge d’autres langages tels que TypeScript, Java, C# et Go.

Le fournisseur Databricks du kit CDK Terraform est basé sur le fournisseur Databricks Terraform. Pour plus d’informations, consultez Problèmes liés à Terraform sur GitHub. Le kit CDKTF est basé sur kit de développement cloud AWS (kit CDK AWS).

Spécifications

Vous devez disposer d’un espace de travail Azure Databricks, car cet article déploie des ressources dans un espace de travail existant.

Sur votre ordinateur de développement local, les éléments suivants installés :

Terraform, version 1.1 ou ultérieure. Pour vérifier si Terraform est installé et vérifier la version installée, exécutez la commande terraform -v à partir de votre terminal ou avec PowerShell. Installez Terraform, si vous ne l’avez pas déjà installé.
```
terraform -v
```
Node.js, version 16.13 ou ultérieure, et npm. Pour vérifier si Node.js et npm sont installés, et pour vérifier les versions installées, exécutez les commandes node -v et npm -v. Les dernières versions de Node.js incluent déjà npm. Installez Node.js et npm à l’aide de Node Version Manager (nvm), si Node.js et npm ne sont pas déjà installés.
```
node -v
npm -v
```
Interface CLI du kit CDKTF. Pour vérifier si l’interface CLI du kit CDKTF est installée, et pour vérifier la version installée, exécutez la commande cdktf --version. Installez l’interface CLI du kit CDKTF à l’aide de npm, si vous ne l’avez pas déjà installée.
```
cdktf --version
```
Conseil

Vous pouvez également installer l’interface CLI du kit CDKTF sur macOS avec Homebrew. Consultez Installer le kit CDKTF.
Python version 3.7 ou ultérieure et pipenv version 2021.5.29 ou ultérieure. Pour vérifier si Python et pipenv sont installés, et pour vérifier les versions installées, exécutez les commandes python --version et pipenv --version. Installez Python et installez pipenv, s’ils ne sont pas déjà installés.
```
python --version
pipenv --version
```
Authentification Azure Databricks configurée pour le type d’authentification pris en charge que vous souhaitez utiliser. Consultez Authentification dans la documentation du fournisseur Databricks Terraform.

Étape 1 : Créer un projet CDKTF

Dans cette étape, sur votre ordinateur de développement local, vous configurez la structure de répertoires nécessaire pour un projet CDKTF. Vous créez ensuite votre projet CDKTF dans cette structure de répertoires.

Créez un répertoire vide pour votre projet CDKTF, puis basculez vers celui-ci. Exécutez les commandes suivantes dans votre terminal ou avec PowerShell :

Unix, Linux et macOS
```
mkdir cdktf-demo
cd cdktf-demo
```
Windows
```
md cdktf-demo
cd cdktf-demo
```
Créez un projet CDKTF en exécutant la commande suivante :
```
cdktf init --template=python --local
```
Quand vous êtes invité à entrer un nom de projet, acceptez le nom de projet par défaut cdktf-demo en appuyant sur Entrée.
Quand vous êtes invité à entrer une description de projet, acceptez la description de projet par défaut en appuyant sur Entrée.
Si l’invite Voulez-vous commencer à partir d’un projet Terraform existant s’affiche, entrez N et appuyez sur Entrée.
Si l’invite Voulez-vous envoyer des rapports d’incident à l’équipe CDKTF s’affiche, entrez n et appuyez sur Entrée.

Le kit CDKTF crée les fichiers et sous-répertoires suivants dans votre répertoire cdktf-demo :

.gitignore, qui est une liste de fichiers et de répertoires que Git ignore si vous souhaitez envoyer ce projet dans un référentiel Git distant.
cdktf.json, qui contient les paramètres de configuration de votre projet CDKTF. Consultez Fichier de configuration pour plus d’informations sur les paramètres de configuration.
help, qui contient des informations sur certaines étapes suivantes que vous pouvez effectuer pour travailler avec votre projet CDKTF.
main-test.py, qui contient la prise en charge des tests unitaires que vous pouvez écrire pour votre projet CDKTF. Consultez Tests unitaires pour plus d’informations sur les tests unitaires.
main.py, qui contient le code Python que vous écrivez pour votre projet CDKTF.
Pipfile et Pipfile.lock, qui gèrent les dépendances de code pour votre projet CDKTF.

Étape 2 : Définir les ressources

Dans cette étape, vous utilisez le fournisseur Databricks du kit CDK Terraform pour définir un notebook et un travail pour exécuter ce notebook.

Installez les dépendances du projet : en utilisant pipenv, installez dans votre projet CDKTF le fournisseur Databricks du kit CDK Terraform pour générer des ressources Azure Databricks. Pour ce faire, exécutez ce qui suit :
```
pipenv install cdktf-cdktf-provider-databricks
```

Remplacez le contenu du fichier main.py par le code suivant. Ce code authentifie le kit CDKTF avec votre espace de travail Azure Databricks, puis génère un notebook avec un travail pour exécuter ce notebook. Pour afficher la documentation sur la syntaxe de ce code, consultez la référence de construction du fournisseur Databricks du CDK Terraform pour Python.

#!/usr/bin/env python
from constructs import Construct
from cdktf import (
  App, TerraformStack, TerraformOutput
)
from cdktf_cdktf_provider_databricks import (
  data_databricks_current_user,
  job, notebook, provider
)
import vars
from base64 import b64encode

class MyStack(TerraformStack):
  def __init__(self, scope: Construct, ns: str):
    super().__init__(scope, ns)

    provider.DatabricksProvider(
      scope = self,
      id    = "databricksAuth"
    )

    current_user = data_databricks_current_user.DataDatabricksCurrentUser(
      scope     = self,
      id_       = "currentUser"
    )

    # Define the notebook.
    my_notebook = notebook.Notebook(
      scope          = self,
      id_            = "notebook",
      path           = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py",
      language       = "PYTHON",
      content_base64 = b64encode(b"display(spark.range(10))").decode("UTF-8")
    )

    # Define the job to run the notebook.
    my_job = job.Job(
      scope = self,
      id_ = "job",
      name = f"{vars.resource_prefix}-job",
      task = [ 
        job.JobTask(
          task_key = f"{vars.resource_prefix}-task",
          new_cluster = job.JobTaskNewCluster(
            num_workers   = vars.num_workers,
            spark_version = vars.spark_version,
            node_type_id  = vars.node_type_id
          ),
          notebook_task = job.JobTaskNotebookTask(
            notebook_path = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py"
          ),
          email_notifications = job.JobTaskEmailNotifications(
            on_success = [ current_user.user_name ],
            on_failure = [ current_user.user_name ]
          )
        )
      ]
    )

    # Output the notebook and job URLs.
    TerraformOutput(
      scope = self,
      id    = "Notebook URL",
      value = my_notebook.url
    )

    TerraformOutput(
      scope = self,
      id    = "Job URL",
      value = my_job.url
    )

app = App()
MyStack(app, "cdktf-demo")
app.synth()

Créez un fichier nommé vars.py dans le même répertoire que main.py. Remplacez les valeurs suivantes par vos propres valeurs pour spécifier un préfixe de ressource et des paramètres de cluster tels que le nombre de workers, la chaîne de version du runtime Spark et le type de nœud.
```
#!/usr/bin/env python
resource_prefix = "cdktf-demo"
num_workers     = 1
spark_version   = "14.3.x-scala2.12"
node_type_id    = "Standard_D3_v2"
```

Étape 3 : Déployer les ressources

Dans cette étape, vous utilisez l’interface CLI du kit CDKTF pour déployer, dans votre espace de travail Azure Databricks existant, le notebook défini et le travail pour exécuter ce notebook.

Générez l’équivalent du code Terraform pour votre projet CDKTF. Pour ce faire, exécutez la commande cdktf synth.
```
cdktf synth
```
Avant d’apporter des modifications, vous pouvez passer en revue les modifications de ressources en attente. Exécutez la commande suivante :
```
cdktf diff
```
Déployez le notebook et le travail en exécutant la commande cdktf deploy.
```
cdktf deploy
```
Quand vous êtes invité à Approuver, appuyez sur Entrée. Terraform crée et déploie le notebook et le travail dans votre espace de travail.

Étape 4 : Interagir avec les ressources

Dans cette étape, vous exécutez le travail dans votre espace de travail Azure Databricks, qui exécute le notebook spécifié.

Pour afficher le notebook que le travail exécutera dans votre espace de travail, copiez le lien URL du notebook qui apparaît dans la sortie de la commande cdk deploy et collez-le dans la barre d’adresse de votre navigateur web.
Pour afficher le travail qui exécute le notebook dans votre espace de travail, copiez le lien URL du travail qui apparaît dans la sortie de la commande cdk deploy et collez-le dans la barre d’adresse de votre navigateur web.
Pour exécuter le travail, cliquez sur le bouton Exécuter maintenant sur la page de travail.

(Facultatif) Étape 5 : Apporter des modifications à une ressource

Dans cette étape facultative, vous modifiez le code du bloc-notes, redéployez le bloc-notes modifié, puis utilisez le travail pour réexécuter le bloc-notes modifié.

Si vous ne souhaitez pas apporter de modifications au bloc-notes, passez à l’étape 6 : Nettoyer.

Dans le fichier main.py, modifiez la déclaration de la variable notebook à partir des éléments suivants :

my_notebook = notebook.Notebook(
  scope          = self,
  id_            = "notebook",
  path           = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py",
  language       = "PYTHON",
  content_base64 = b64encode(b"display(spark.range(10))").decode("UTF-8")
)

par ce qui suit :

my_notebook = notebook.Notebook(
  scope          = self,
  id_            = "notebook",
  path           = f"{current_user.home}/CDKTF/{vars.resource_prefix}-notebook.py",
  language       = "PYTHON",
  content_base64 = b64encode(b'''
data = [
   { "Category": 'A', "ID": 1, "Value": 121.44 },
   { "Category": 'B', "ID": 2, "Value": 300.01 },
   { "Category": 'C', "ID": 3, "Value": 10.99 },
   { "Category": 'E', "ID": 4, "Value": 33.87}
]

df = spark.createDataFrame(data)

display(df)
''').decode("UTF-8")
)

Notes

Assurez-vous que les lignes de code entre triples guillemets (''') sont alignées avec le bord de votre éditeur de code, comme illustré. Dans le cas contraire, Terraform insère un autre espace blanc dans le notebook qui peut entraîner l’échec de l’exécution du nouveau code Python.

Regénérez l’équivalent du code Terraform pour votre projet CDKTF. Pour ce faire, exécutez ce qui suit :
```
cdktf synth
```
Avant d’apporter des modifications, vous pouvez passer en revue les modifications de ressources en attente. Exécutez la commande suivante :
```
cdktf diff
```
Déployez les modifications du notebook en exécutant la commande cdktf deploy.
```
cdktf deploy
```
Quand vous êtes invité à Approuver, appuyez sur Entrée. Terraform modifie le contenu du notebook.
Pour afficher le notebook modifié que le travail exécutera dans votre espace de travail, actualisez le notebook que vous avez ouvert auparavant, ou copiez le lien URL du notebook qui apparaît dans la sortie de la commande cdk deploy et collez-le dans la barre d’adresse de votre navigateur web.
Pour afficher le travail qui exécute le notebook modifié dans votre espace de travail, actualisez le travail que vous avez ouvert auparavant, ou copiez le lien URL du travail qui apparaît dans la sortie de la commande cdk deploy et collez-le dans la barre d’adresse de votre navigateur web.
Pour exécuter le travail, cliquez sur le bouton Exécuter maintenant sur la page de travail.

Étape 6 : nettoyer

Dans cette étape, vous utilisez l’interface CLI du kit CDKTF pour supprimer le notebook et le travail de votre espace de travail Azure Databricks.

Supprimez les ressources de votre espace de travail en exécutant la commande cdktf destroy :
```
cdktf destroy
```
Quand vous êtes invité à Approuver, appuyez sur Entrée. Terraform supprime les ressources de votre espace de travail.

Test

Vous pouvez tester votre projet CDKTF avant de le déployer. Consultez Tests unitaires dans la documentation CDKTF.

Pour les projets CDKTF basés sur Python, vous pouvez écrire et exécuter des tests en utilisant l’infrastructure de test Python pytest avec la classe cdktf du packageTesting. L’exemple de fichier suivant nommé test_main.py teste le code CDKTF du fichier main.py précédent de cet article. Le premier test vérifie si le notebook du projet contiendra la représentation attendue du contenu du notebook encodée en Base64. Le deuxième test vérifie si le travail du projet contiendra le nom du travail attendu. Pour exécuter ces tests, exécutez la commande pytest à partir du répertoire racine du projet.

from cdktf import App, Testing
from cdktf_cdktf_provider_databricks import job, notebook
from main import MyStack

class TestMain:
  app = App()
  stack = MyStack(app, "cdktf-demo")
  synthesized = Testing.synth(stack)

  def test_notebook_should_have_expected_base64_content(self):
    assert Testing.to_have_resource_with_properties(
      received = self.synthesized,
      resource_type = notebook.Notebook.TF_RESOURCE_TYPE,
      properties = {
        "content_base64": "ZGlzcGxheShzcGFyay5yYW5nZSgxMCkp"
      }
    )

  def test_job_should_have_expected_job_name(self):
    assert Testing.to_have_resource_with_properties(
      received = self.synthesized,
      resource_type = job.Job.TF_RESOURCE_TYPE,
      properties = {
        "name": "cdktf-demo-job"
      }
    )

Plus de ressources

Référence de construction du fournisseur Databricks du kit CDK Terraform pour TypeScript, Python, Java, C# et Go
Activation de la journalisation pour les applications CDKTF

Partager via