Condividi tramite

Usare uno script Python per distribuire un cluster Big Data di SQL Server in Azure Red Hat OpenShift (ARO)

Si applica a:SQL Server 2019 (15.x)

Important

I cluster Big Data di Microsoft SQL Server 2019 sono stati ritirati. Il supporto per i cluster Big Data di SQL Server 2019 è terminato a partire dal 28 febbraio 2025. Per altre informazioni, vedere il post di blog sull'annuncio e le opzioni per Big Data nella piattaforma Microsoft SQL Server.

In questa esercitazione si usa uno script di distribuzione Python di esempio per distribuire cluster Big Data di SQL Server 2019 in Azure Red Hat OpenShift (ARO). Questa opzione di distribuzione è supportata a partire da SQL Server 2019 CU5.

Tip

ARO è una sola opzione per l'hosting di Kubernetes per il cluster Big Data. Per informazioni su altre opzioni di distribuzione e su come personalizzare le opzioni di distribuzione, vedere Come distribuire cluster Big Data di SQL Server in Kubernetes.

Warning

I volumi permanenti creati con la classe di archiviazione predefinita managed-premium hanno un criterio di recupero di Elimina. Pertanto, quando si elimina il cluster Big Data di SQL Server, le richieste di volume persistente vengono eliminate così come i volumi persistenti. È consigliabile creare classi di archiviazione personalizzate usando il provisioner azure-disk con un criterio di recupero Retain, come descritto in Concetti di archiviazione. Lo script seguente usa la classe di archiviazione Managed-Premium . Per altri dettagli, vedere l'argomento Relativo alla persistenza dei dati .

La distribuzione predefinita del cluster Big Data usata qui è costituita da un'istanza master DI SQL, un'istanza del pool di calcolo, due istanze del pool di dati e due istanze del pool di archiviazione. I dati vengono mantenuti usando volumi permanenti Kubernetes che usano le classi di archiviazione predefinite ARO. La configurazione predefinita usata in questa esercitazione è adatta per ambienti di sviluppo/test.

Prerequisites

Accedi al tuo account Azure

Lo script usa l'interfaccia della riga di comando di Azure per automatizzare la creazione di un cluster ARO. Prima di eseguire lo script, è necessario accedere all'account Azure con l'interfaccia della riga di comando di Azure almeno una volta. Eseguire il comando seguente da un prompt dei comandi.

az login

Instructions

  1. Scaricare sia lo script deploy-sql-big-data-aro.py Python che il file bdc-scc.yamlyaml .

    Questi file si trovano in questo articolo sotto:

  2. Eseguire lo script usando:

python deploy-sql-big-data-aro.py

Quando richiesto, inserire l'ID della sottoscrizione di Azure e il gruppo di risorse di Azure nel quale creare le risorse. Facoltativamente, è anche possibile specificare l'input per altre configurazioni o usare le impostazioni predefinite specificate. For example:

  • azure_region
  • vm_size per i nodi di lavoro OpenShift. Per un'esperienza ottimale durante la convalida degli scenari di base, è consigliabile usare almeno 8 vCPU e 64 GB di memoria in tutti i nodi di lavoro del cluster. Lo script usa Standard_D8s_v3 e tre nodi di lavoro come impostazione predefinita. Una configurazione di dimensioni predefinite per i cluster Big Data usa anche circa 24 dischi per attestazioni di volume persistente in tutti i componenti.
  • configurazione di rete per la distribuzione del cluster OpenShift: vedere l'articolo sulla distribuzione ARO per altri dettagli su ogni parametro.
  • cluster_name : questo valore viene usato sia per il cluster ARO che per il cluster Big Data di SQL Server creato sopra ARO. Il nome del SQL Big Data Cluster sarà un namespace di Kubernetes.
  • username - questo è il nome utente per gli account configurati durante la distribuzione per l'account amministratore del controller, l'account dell'istanza master di SQL Server e il gateway. sa L'account DI SQL Server viene disabilitato automaticamente, come procedura consigliata.
  • password - Lo stesso valore verrà usato per tutti gli account.

Il cluster Big Data di SQL Server è ora distribuito in ARO. È ora possibile usare Azure Data Studio per connettersi al cluster. Per altre informazioni, vedere Connettersi a un cluster Big Data di SQL Server con Azure Data Studio.

Clean up

Se si testano cluster Big Data di SQL Server in Azure, è necessario eliminare il cluster ARO al termine per evitare addebiti imprevisti. Non rimuovere il cluster se si intende continuare a usarlo.

Warning

La procedura seguente rimuove il cluster ARO che rimuove anche il cluster Big Data di SQL Server. Se sono presenti database o dati HDFS da conservare, eseguire il backup dei dati prima di eliminare il cluster.

Eseguire il comando seguente dell'interfaccia della riga di comando di Azure per rimuovere il cluster Big Data e il servizio ARO in Azure (sostituire <resource group name> con il gruppo di risorse di Azure specificato nello script di distribuzione):

az group delete -n <resource group name>

deploy-SQL-big-data-aro.py

Lo script in questa sezione distribuisce il cluster Big Data di SQL Server in Azure Red Hat OpenShift. Copiare lo script nella workstation e salvarlo come deploy-sql-big-data-aro.py prima di iniziare la distribuzione.

#
# Prerequisites: 
# 
# Azure CLI, Azure Data CLI (`azdata`), OpenShift CLI (oc)  
#
# Run `az login` at least once BEFORE running this script
#

from subprocess import check_output, CalledProcessError, STDOUT, Popen, PIPE, getoutput
from time import sleep
import os
import getpass
import json

def executeCmd (cmd):
    if os.name=="nt":
        process = Popen(cmd.split(),stdin=PIPE, shell=True)
    else:
        process = Popen(cmd.split(),stdin=PIPE)
    stdout, stderr = process.communicate()
    if (stderr is not None):
        raise Exception(stderr)

#
# MUST INPUT THESE VALUES!!!!!
#
SUBSCRIPTION_ID = input("Provide your Azure subscription ID:").strip()
GROUP_NAME = input("Provide Azure resource group name to be created:").strip()
#
# This password will be use for Controller user, Gateway user and SQL Server Master SA accounts
AZDATA_USERNAME=input("Provide username to be used for Controller, SQL Server and Gateway endpoints - Press ENTER for using  `admin`:").strip() or "admin"
AZDATA_PASSWORD = getpass.getpass("Provide password to be used for Controller user, Gateway user and SQL Server Master accounts:")
#
# Optionally change these configuration settings
#
AZURE_REGION=input("Provide Azure region - Press ENTER for using `westus2`:").strip() or "westus2"
# MASTER_VM_SIZE=input("Provide VM size for master nodes for the ARO cluster - Press ENTER for using  `Standard_D2s_v3`:").strip() or "Standard_D2s_v3"
WORKER_VM_SIZE=input("Provide VM size for the worker nodes for the ARO cluster - Press ENTER for using  `Standard_D8s_v3`:").strip() or "Standard_D8s_v3"
OC_NODE_COUNT=input("Provide number of worker nodes for ARO cluster - Press ENTER for using  `3`:").strip() or "3"
VNET_NAME=input("Provide name of Virtual Network for ARO cluster - Press ENTER for using  `aro-vnet`:").strip() or "aro-vnet"
VNET_ADDRESS_SPACE=input("Provide Virtual Network Address Space for ARO cluster - Press ENTER for using  `10.0.0.0/16`:").strip() or "10.0.0.0/16"
MASTER_SUBNET_NAME=input("Provide Master Subnet Name for ARO cluster - Press ENTER for using  `master-subnet`:").strip() or "master-subnet"
MASTER_SUBNET_IP_RANGE=input("Provide address range of Master Subnet for ARO cluster - Press ENTER for using  `10.0.0.0/23`:").strip() or "10.0.0.0/23"
WORKER_SUBNET_NAME=input("Provide Worker Subnet Name for ARO cluster - Press ENTER for using  `worker-subnet`:").strip() or "worker-subnet"
WORKER_SUBNET_IP_RANGE=input("Provide address range of Worker Subnet for ARO cluster - Press ENTER for using  `10.0.2.0/23`:").strip() or "10.0.2.0/23"
#
# This is both Kubernetes cluster name and SQL Big Data cluster name
CLUSTER_NAME=input("Provide name of OpenShift cluster and SQL big data cluster - Press ENTER for using  `sqlbigdata`:").strip() or "sqlbigdata"
#
# Deploy the ARO cluster
#  
print ("Set azure context to subscription: "+SUBSCRIPTION_ID)
command = "az account set -s "+ SUBSCRIPTION_ID
executeCmd (command)
print ("Creating azure resource group: "+GROUP_NAME)
command="az group create --name "+GROUP_NAME+" --location "+AZURE_REGION
executeCmd (command)
command = "az network vnet create --resource-group "+GROUP_NAME+" --name "+VNET_NAME+" --address-prefixes "+VNET_ADDRESS_SPACE
print("Creating Virtual Network: "+VNET_NAME)
executeCmd(command)
command = "az network vnet subnet create --resource-group "+GROUP_NAME+" --vnet-name "+VNET_NAME+" --name "+MASTER_SUBNET_NAME+" --address-prefixes "+MASTER_SUBNET_IP_RANGE+" --service-endpoints Microsoft.ContainerRegistry"
print("Creating Master Subnet: "+MASTER_SUBNET_NAME)
executeCmd(command)
command = "az network vnet subnet create --resource-group "+GROUP_NAME+" --vnet-name "+VNET_NAME+" --name "+WORKER_SUBNET_NAME+" --address-prefixes "+WORKER_SUBNET_IP_RANGE+" --service-endpoints Microsoft.ContainerRegistry"
print("Creating Worker Subnet: "+WORKER_SUBNET_NAME)
executeCmd(command)
command = "az network vnet subnet update --name "+MASTER_SUBNET_NAME+" --resource-group "+GROUP_NAME+" --vnet-name "+VNET_NAME+" --disable-private-link-service-network-policies true"
print("Updating Master Subnet by disabling Private Link Policies")
executeCmd(command)
command = "az aro create --resource-group "+GROUP_NAME+" --name "+CLUSTER_NAME+" --vnet "+VNET_NAME+" --master-subnet "+MASTER_SUBNET_NAME+" --worker-subnet "+WORKER_SUBNET_NAME+" --worker-count "+OC_NODE_COUNT+" --worker-vm-size "+WORKER_VM_SIZE +" --only-show-errors"
print("Creating OpenShift cluster: "+CLUSTER_NAME)
executeCmd (command)
#
# Login to oc console
#
command = "az aro list-credentials --name "+CLUSTER_NAME+" --resource-group "+GROUP_NAME +" --only-show-errors"
output=json.loads(getoutput(command))
OC_CLUSTER_USERNAME = str(output['kubeadminUsername'])
OC_CLUSTER_PASSWORD = str(output['kubeadminPassword'])
command = "az aro show --name "+CLUSTER_NAME+" --resource-group "+GROUP_NAME +" --only-show-errors"
output=json.loads(getoutput(command))
APISERVER = str(output['apiserverProfile']['url'])
command = "oc login "+ APISERVER+ " -u " + OC_CLUSTER_USERNAME + " -p "+ OC_CLUSTER_PASSWORD
executeCmd (command)
#
# Setup pre-requisites for deploying BDC on OpenShift
#
#
#Creating new project/namespace
command = "oc new-project "+ CLUSTER_NAME
executeCmd (command)
#
# create custom SCC for BDC
command = "oc apply -f bdc-scc.yaml"
executeCmd (command)
#
#Bind the custom scc with service accounts in the BDC namespace
command = "oc create clusterrole bdc-role --verb=use --resource=scc --resource-name=bdc-scc -n " + CLUSTER_NAME
executeCmd (command)
command = "oc create rolebinding bdc-rbac --clusterrole=bdc-role --group=system:serviceaccounts:" + CLUSTER_NAME
executeCmd (command)
#
# Deploy big data cluster
#
print ('Set environment variables for credentials')
os.environ['AZDATA_PASSWORD'] = AZDATA_PASSWORD
os.environ['AZDATA_USERNAME'] = AZDATA_USERNAME
os.environ['ACCEPT_EULA']="Yes"
#
#Creating azdata configuration with aro-dev-test profile
command = "azdata bdc config init --source aro-dev-test --target custom --force"
executeCmd (command)
command="azdata bdc config replace -c custom/bdc.json -j ""metadata.name=" + CLUSTER_NAME + ""
executeCmd (command)
#
# Create BDC
command = "azdata bdc create --config-profile custom --accept-eula yes"
executeCmd(command)
#login into big data cluster and list endpoints
command="azdata login -n " + CLUSTER_NAME
executeCmd (command)
print("")
print("SQL Server big data cluster endpoints: ")
command="azdata bdc endpoint list -o table"
executeCmd(command)

bdc-scc.yaml

Il manifesto yaml seguente definisce un vincolo di contesto di sicurezza personalizzato (SCC) per la distribuzione del cluster Big Data. Copialo nella stessa directory di deploy-sql-big-data-aro.py.

allowHostDirVolumePlugin: false
allowHostIPC: false
allowHostNetwork: false
allowHostPID: false
allowHostPorts: false
allowPrivilegeEscalation: true
allowPrivilegedContainer: false
allowedCapabilities:
  - SETUID
  - SETGID
  - CHOWN
  - SYS_PTRACE
apiVersion: security.openshift.io/v1
defaultAddCapabilities: null
fsGroup:
  type: RunAsAny
kind: SecurityContextConstraints
metadata:
  annotations:
    kubernetes.io/description: SQL Server BDC custom scc is based on 'nonroot' scc plus additional capabilities required by BDC.
  generation: 2
  name: bdc-scc
readOnlyRootFilesystem: false
requiredDropCapabilities:
  - KILL
  - MKNOD
runAsUser:
  type: MustRunAsNonRoot
seLinuxContext:
  type: MustRunAs
supplementalGroups:
  type: RunAsAny
volumes:
  - configMap
  - downwardAPI
  - emptyDir
  - persistentVolumeClaim
  - projected
  - secret

Related content

  • Last updated on