Provisionamento automatizado no Azure Data Explorer

O provisionamento automatizado é um processo para implantar e configurar rapidamente os recursos de que você precisa para executar o cluster do Azure Data Explorer. É uma parte crítica de um fluxo de trabalho DevOps ou DataOps. O processo de provisionamento não exige que você configure o cluster manualmente, não requer intervenção humana e é fácil de configurar.

Você pode usar o provisionamento automatizado para implantar um cluster pré-configurado com os dados, como parte de um pipeline de CI/CD (integração contínua e entrega contínua). Alguns dos principais benefícios de fazer isso incluem a capacidade de:

Definir e manter vários ambientes.
Acompanhar implantações no controle do código-fonte.
Reverter mais facilmente para versões anteriores.
Facilitar o teste automatizado ao provisionar ambientes de teste dedicados.

Este artigo fornece uma visão geral dos diferentes mecanismos para automatizar o provisionamento de ambientes de Azure Data Explorer, incluindo infraestrutura, entidades de esquema e ingestão de dados. Ele também fornece referências às diferentes ferramentas e técnicas usadas para automatizar o processo de provisionamento.

Imagem mostrando o fluxo geral de implantação.

Implantar a infraestrutura

A implantação de infraestrutura refere-se à implantação de recursos do Azure, incluindo clusters, bancos de dados e conexões de dados. Há vários tipos diferentes de implantações de infraestrutura, incluindo:

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

Os modelos do ARM e os scripts do Terraform são as duas principais maneiras declarativas de implantar a infraestrutura do Azure Data Explorer.

Implantação do modelo do ARM

Os modelos do ARM são arquivos JSON ou Bicep que definem a infraestrutura e a configuração de uma implantação. Use os modelos para implantar clusters, bancos de dados, conexões de dados e muitos outros componentes de infraestrutura. Para obter mais informações, confira Criar um cluster do Azure Data Explorer e um banco de dados usando um modelo do Azure Resource Manager.

Você também pode usar modelos do ARM para implantar scripts de comando, que ajudam a criar um esquema de banco de dados e definir políticas. Para obter mais informações, veja Configurar um banco de dados usando um script da Linguagem de Consulta Kusto.

Você pode encontrar mais modelos de exemplo no site de Modelos de início rápido do Azure.

Implantação do Terraform

O Terraform é uma ferramenta de código aberto de software de infraestrutura como código. Ele fornece um fluxo de trabalho de CLI consistente para gerenciar serviços de nuvem. O Terraform codifica as APIs de nuvem em arquivos de configuração declarativos.

O Terraform oferece os mesmos recursos que os modelos do ARM. Use o Terraform para implantar clusters, bancos de dados, conexões de dados e outros componentes de infraestrutura.

Você também pode usar o Terraform para implantar scripts de comando, que ajudam a criar um esquema de banco de dados e definir políticas.

Implantação imperativa

Você também pode implantar a infraestrutura imperativamente, usando qualquer uma das plataformas com suporte:

Implantar entidades de esquema

O provisionamento de entidades de esquema faz parte da implantação de tabelas, funções, políticas e permissões. Você pode criar ou atualizar entidades executando scripts que consistem em comandos de gerenciamento.

Você pode automatizar a implantação de entidades de esquema usando os seguintes métodos:

Modelos do ARM
Scripts do Terraform
CLI Kusto
SDKs
Ferramentas
- Sync Kusto. Use esta ferramenta de desenvolvedor interativa para extrair o esquema de banco de dados ou o script de comando de gerenciamento. Você pode usar o script de comando de conteúdo extraído para implantação automática.
- Delta Kusto: invoque essa ferramenta em um pipeline de CI/CD. Ele pode comparar duas fontes, como o esquema de banco de dados ou o script de comando de gerenciamento, e calcular um script de comando de gerenciamento delta. Você pode usar o script de comando de conteúdo extraído para implantação automática.
- Tarefa do Azure DevOps para o Azure Data Explorer.

Ingestão de dados

Às vezes, você deseja ingerir dados em seu cluster. Por exemplo, pode ser interessante ingerir dados para executar testes ou recriar um ambiente. Você pode usar os seguintes métodos para ingerir dados:

SDKs
Ferramenta de CLI LightIngest
Disparar um pipeline do Azure Data Factory

Exemplo de implantação usando um pipeline de CI/CD

No exemplo a seguir, você usará um pipeline de CI/CD do Azure DevOps que executa ferramentas para automatizar a implantação de infraestrutura, de entidades de esquema e de dados. Este é um exemplo de um pipeline que usa um conjunto específico de ferramentas, mas você pode usar outras ferramentas e etapas. Por exemplo, em um ambiente de produção, você pode criar um pipeline que não faça ingestão de dados. Você também pode adicionar outras etapas ao pipeline, como a execução de testes automatizados no cluster criado.

Aqui, você usa as seguintes ferramentas:

Tipo de implantação	Ferramenta	Tarefa
Infraestrutura	Modelos do ARM	Criar um cluster e um banco de dados
Entidades de esquema	CLI Kusto	Criar tabelas no banco de dados
Dados	LightIngest	Faça a ingestão da dados em uma tabela

Imagem mostrando o fluxo de exemplo de implantação.

Use as etapas a seguir para criar um pipeline.

Etapa 1: Criar uma conexão de serviço

Defina uma conexão de serviço do tipo Azure Resource Manager. Aponte a conexão para a assinatura e o grupo de recursos no qual você deseja implantar o cluster. Uma entidade de serviço do Azure será criada e você a usará para implantar o modelo do ARM. Você pode usar a mesma entidade de serviço para implantar entidades de esquema e ingerir dados. Você deve passar explicitamente as credenciais para a CLI do Kusto e as ferramentas LightIngest.

Etapa 2: Criar um pipeline

Defina o pipeline (deploy-environ) que será usado para implantar o cluster, criar entidades de esquema e ingerir dados.

Para usar o pipeline, crie as seguintes variáveis secretas:

Nome da variável	Descrição
`clusterName`	O nome do cluster do Azure Data Explorer.
`serviceConnection`	O nome da conexão do Azure DevOps usada para implantar o modelo do ARM.
`appId`	A ID do cliente da entidade de serviço usada para interagir com o cluster.
`appSecret`	O segredo da entidade de serviço.
`appTenantId`	A ID do locatário da entidade de serviço.
`location`	A região do Azure em que você implantará 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

Etapa 3: Criar um modelo do ARM para implantar o cluster

Defina o modelo do ARM (deploy-infra.json) que será usado para implantar o cluster em sua assinatura e seu 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
                    }
                }
            ]
        }
    ]
}

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

Defina o script da KQL (MyDatabase.kql) que você vai usar para criar as tabelas nos bancos 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)

Etapa 5: Criar um script KQL para ingerir dados

Crie o arquivo de dados CSV (customer.csv) a ser ingerido.

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

Captura de tela mostrando uma execução de trabalho do fluxo de exemplo.

Você cria o cluster usando as credenciais da entidade de serviço que foram especificadas no pipeline. Para dar permissões aos usuários, use as etapas em Gerenciar permissões do banco de dados do Azure Data Explorer.

Captura de tela mostrando o banco de dados implantado com suas duas tabelas na interface do usuário da Web do Azure Data Explorer.

Você pode verificar a implantação executando uma consulta na tabela Cliente. Você deverá ver os três registros que foram importados do arquivo CSV.

Criar um cluster e um banco de dados usando um modelo do Azure Resource Manager.
Configurar um banco de dados usando um script da KQL

Comentários

Esta página foi útil?

Última atualização em 2023-06-20