Aprovisionamento automatizado no Azure Data Explorer

O aprovisionamento automatizado é um processo para implementar e configurar rapidamente os recursos necessários para executar o cluster do Azure Data Explorer. É uma parte crítica de um fluxo de trabalho de DevOps ou DataOps. O processo de aprovisionamento não requer a configuração manual do cluster, não requer intervenção humana e é fácil de configurar.

Pode utilizar o aprovisionamento automatizado para implementar um cluster pré-configurado com dados, como parte de um pipeline de integração contínua e entrega contínua (CI/CD). Algumas das principais vantagens de o fazer incluem a capacidade de:

Definir e manter múltiplos ambientes.
Controle as implementações no controlo de origem.
Reverter mais facilmente para versões anteriores.
Facilitar os testes automatizados através do aprovisionamento de ambientes de teste dedicados.

Este artigo fornece uma descrição geral dos diferentes mecanismos para automatizar o aprovisionamento de ambientes do Azure Data Explorer, incluindo infraestrutura, entidades de esquema e ingestão de dados. Também fornece referências às diferentes ferramentas e técnicas utilizadas para automatizar o processo de aprovisionamento.

Imagem a mostrar o fluxo geral da implementação.

Implementar infraestrutura

A implementação da infraestrutura diz respeito à implementação de recursos do Azure, incluindo clusters, bases de dados e ligações de dados. Existem vários tipos diferentes de implementações de infraestrutura, incluindo:

Implementação do modelo do Azure Resource Manager (ARM)
Implementação do Terraform
Implementação imperativa

Os modelos arm e os scripts do Terraform são as duas principais formas declarativas de implementar a infraestrutura de Data Explorer do Azure.

Implementação de modelos do ARM

Os modelos do ARM são ficheiros JSON ou Bicep que definem a infraestrutura e a configuração de uma implementação. Pode utilizar os modelos para implementar clusters, bases de dados, ligações de dados e muitos outros componentes de infraestrutura. Para obter mais informações, veja Create an Azure Data Explorer cluster and database by using an Azure Resource Manager template (Criar um cluster e uma base de dados do Azure Data Explorer com um modelo de Resource Manager do Azure).

Também pode utilizar modelos do ARM para implementar scripts de comandos, o que o ajuda a criar um esquema de base de dados e a definir políticas. Para obter mais informações, veja Configurar uma base de dados com um script de Linguagem de Pesquisa Kusto.

Pode encontrar mais modelos de exemplo no site Modelos de Início Rápido do Azure .

Implementação do Terraform

O Terraform é uma ferramenta de software open source, infraestrutura como código. Fornece um fluxo de trabalho consistente da CLI para gerir serviços cloud. O Terraform codifica as APIs da cloud em ficheiros de configuração declarativas.

O Terraform oferece as mesmas capacidades que os modelos do ARM. Pode utilizar o Terraform para implementar clusters, bases de dados, ligações de dados e outros componentes de infraestrutura.

Também pode utilizar o Terraform para implementar scripts de comandos, o que o ajuda a criar um esquema de base de dados e a definir políticas.

Implementação imperativa

Também pode implementar a infraestrutura de forma imperativa ao utilizar qualquer uma das plataformas suportadas:

Implementar entidades de esquema

O aprovisionamento de entidades de esquema diz respeito à implementação de tabelas, funções, políticas e permissões. Pode criar ou atualizar entidades ao executar scripts que consistem em comandos de gestão.

Pode automatizar a implementação de entidades de esquema com os seguintes métodos:

Modelos do ARM
Scripts do Terraform
Kusto CLI
SDKs
Ferramentas
- Sincronize o Kusto. Utilize esta ferramenta de programador interativa para extrair o script de comandos de gestão ou esquema de base de dados. Em seguida, pode utilizar o script de comando de conteúdo extraído para a implementação automática.
- Delta Kusto: invoque esta ferramenta num pipeline CI/CD. Pode comparar duas origens, como o esquema da base de dados ou o script de comandos de gestão, e calcular um script de comandos de gestão delta. Em seguida, pode utilizar o script de comando de conteúdo extraído para a implementação automática.
- Tarefa do Azure DevOps para Data Explorer do Azure.

Ingerir dados

Por vezes, quer ingerir dados no cluster. Por exemplo, poderá querer ingerir dados para executar testes ou recriar um ambiente. Pode utilizar os seguintes métodos para ingerir dados:

SDKs
LightIngest Ferramenta da CLI
Acionar um pipeline de Azure Data Factory

Implementação de exemplo com um pipeline CI/CD

No exemplo seguinte, vai utilizar um pipeline CI/CD do Azure DevOps que executa ferramentas para automatizar a implementação de infraestrutura, entidades de esquema e dados. Este é um exemplo de um pipeline que utiliza um conjunto específico de ferramentas, mas pode utilizar outras ferramentas e passos. Por exemplo, num ambiente de produção, poderá querer criar um pipeline que não ingere dados. Também pode adicionar mais passos ao pipeline, como executar testes automatizados no cluster criado.

Aqui, pode utilizar as seguintes ferramentas:

Tipo de implementação	Ferramenta	Tarefa
Infraestrutura	Modelos de ARM	Criar um cluster e uma base de dados
Entidades de esquema	Kusto CLI	Criar tabelas na base de dados
Dados	LightIngest	Ingerir dados numa tabela

Imagem a mostrar o fluxo de exemplo de implementação.

Utilize os seguintes passos para criar um pipeline.

Passo 1: Criar uma ligação de serviço

Defina uma ligação de serviço do tipo Azure Resource Manager. Aponte a ligação para a subscrição e o grupo de recursos no qual pretende implementar o cluster. É criado um principal de serviço do Azure e pode utilizá-lo para implementar o modelo do ARM. Pode utilizar o mesmo principal para implementar as entidades de esquema e ingerir dados. Tem de transmitir explicitamente as credenciais à CLI do Kusto e às ferramentas LightIngest.

Passo 2: criar um pipeline

Defina o pipeline (deploy-environ) que irá utilizar para implementar o cluster, criar entidades de esquema e ingerir dados.

Antes de poder utilizar o pipeline, tem de criar as seguintes variáveis secretas:

Nome da variável	Description
`clusterName`	O nome do cluster do Azure Data Explorer.
`serviceConnection`	O nome da ligação do Azure DevOps utilizada para implementar o modelo do ARM.
`appId`	O ID de cliente do principal de serviço utilizado para interagir com o cluster.
`appSecret`	O segredo do principal de serviço.
`appTenantId`	O ID de inquilino do principal de serviço.
`location`	A região do Azure onde irá implementar o cluster. Por exemplo, `eastus`.

resources:
- repo: self

stages:
- stage: deploy_cluster
  displayName: Deploy cluster
  variables: []
    clusterName: specifyClusterName
    serviceConnection: specifyServiceConnection
    appId: specifyAppId
    appSecret: specifyAppSecret
    appTenantId: specifyAppTenantId
    location: specifyLocation
  jobs:
  - job: e2e_deploy
    pool:
      vmImage: windows-latest
    variables: []
    steps:
    - bash: |
        nuget install Microsoft.Azure.Kusto.Tools -Version 5.3.1
        # Rename the folder (including the most recent version)
        mv Microsoft.Azure.Kusto.Tools.* kusto.tools
      displayName: Download required Kusto.Tools Nuget package
    - task: AzureResourceManagerTemplateDeployment@3
      displayName: Deploy Infrastructure
      inputs:
        deploymentScope: 'Resource Group'
        # subscriptionId and resourceGroupName are specified in the serviceConnection
        azureResourceManagerConnection: $(serviceConnection)
        action: 'Create Or Update Resource Group'
        location: $(location)
        templateLocation: 'Linked artifact'
        csmFile: deploy-infra.json
        overrideParameters: "-clusterName $(clusterName)"
        deploymentMode: 'Incremental'
    - bash: |
        # Define connection string to cluster's database, including service principal's credentials
        connectionString="https://$(clusterName).$(location).kusto.windows.net/myDatabase;Fed=true;AppClientId=$(appId);AppKey=$(appSecret);TenantId=$(appTenantId)"
        # Execute a KQL script against the database
        kusto.tools/tools/Kusto.Cli $connectionString -script:MyDatabase.kql
      displayName: Create Schema Entities
    - bash: |
        connectionString="https://ingest-$(CLUSTERNAME).$(location).kusto.windows.net/;Fed=true;AppClientId=$(appId);AppKey=$(appSecret);TenantId=$(appTenantId)"
        kusto.tools/tools/LightIngest $connectionString -table:Customer -sourcePath:customers.csv -db:myDatabase -format:csv -ignoreFirst:true
      displayName: Ingest Data

Passo 3: criar um modelo do ARM para implementar o cluster

Defina o modelo do ARM (deploy-infra.json) que irá utilizar para implementar o cluster na sua subscrição e grupo de recursos.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "clusterName": {
            "type": "string",
            "minLength": 5
        }
    },
    "variables": {
    },
    "resources": [
        {
            "name": "[parameters('clusterName')]",
            "type": "Microsoft.Kusto/clusters",
            "apiVersion": "2021-01-01",
            "location": "[resourceGroup().location]",
            "sku": {
                "name": "Dev(No SLA)_Standard_E2a_v4",
                "tier": "Basic",
                "capacity": 1
            },
            "resources": [
                {
                    "name": "myDatabase",
                    "type": "databases",
                    "apiVersion": "2021-01-01",
                    "location": "[resourceGroup().location]",
                    "dependsOn": [
                        "[resourceId('Microsoft.Kusto/clusters', parameters('clusterName'))]"
                    ],
                    "kind": "ReadWrite",
                    "properties": {
                        "softDeletePeriodInDays": 365,
                        "hotCachePeriodInDays": 31
                    }
                }
            ]
        }
    ]
}

Passo 4: Criar um script KQL para criar as entidades de esquema

Defina o script KQL (MyDatabase.kql) que irá utilizar para criar as tabelas nas bases de dados.

.create table Customer(CustomerName:string, CustomerAddress:string)

//  Set the ingestion batching policy to trigger ingestion quickly
//  This is to speedup reaction time for the sample
//  Do not do this in production
.alter table Customer policy ingestionbatching @'{"MaximumBatchingTimeSpan":"00:00:10", "MaximumNumberOfItems": 500, "MaximumRawDataSizeMB": 1024}'

.create table CustomerLogs(CustomerName:string, Log:string)

Passo 5: Criar um script KQL para ingerir dados

Crie o ficheiro de dados CSV (customer.csv) para ingerir.

customerName,customerAddress
Contoso Ltd,Paris
Datum Corporation,Seattle
Fabrikam,NYC

Captura de ecrã a mostrar uma execução de trabalho do fluxo de exemplo.

Pode criar o cluster com as credenciais do principal de serviço que especificou no pipeline. Para conceder permissões aos seus utilizadores, siga os passos em Gerir permissões de base de dados do Azure Data Explorer.

Captura de ecrã a mostrar a base de dados implementada com as duas tabelas no Azure Data Explorer IU da Web.

Pode verificar a implementação ao executar uma consulta na tabela Cliente . Deverá ver os três registos que foram importados do ficheiro CSV.

Crie um cluster e uma base de dados com um modelo do Azure Resource Manager.
Configurar uma base de dados com um script KQL

Comentários

Esta página foi útil?

Última atualização a 2023-06-08