Come avviare un'istanza SQL Server su macOS Apple Silicon
Tags: database, sqlserver, macos
Published: 2023-10-03 14:14:22

---
title: Come avviare un'istanza SQL Server su macOS Apple Silicon
published: true
date: 2023-09-28 00:00:00 UTC
tags:
  - "database"
  - "sqlserver"
  - "macOS"

canonical_url: 
---

[Microsoft SQL Server](https://www.microsoft.com/en-us/sql-server) è uno dei sistemi di gestione dei database ([RDBMS](https://it.wikipedia.org/wiki/Relational_database_management_system)) più popolari al mondo ma tradizionalmente era stato limitato all’uso su piattaforme con sistema operativo Windows. Attualmente, Microsoft SQL Server non è ufficialmente supportato per essere eseguito su [macOS Apple Silicon](https://it.wikipedia.org/wiki/Apple_Silicon) ma solo su piattaforme hardware basate su architettura [x86\_64](https://it.wikipedia.org/wiki/X86-64) e sistemi operativi Windows e Linux.

> Per maggiori informazioni sul supporto Linux, consiglio la lettura del documento [Installation guidance for SQL Server on Linux](https://learn.microsoft.com/en-us/sql/linux/sql-server-linux-setup?view=sql-server-ver16) e in particolare il paragrafo [Supported platforms](https://learn.microsoft.com/en-us/sql/linux/sql-server-linux-setup?view=sql-server-ver16#supportedplatforms).

Qualora tu fossi un utente [macOS](https://www.apple.com/macos/ventura/) (Apple Silicon) e avessi bisogno di utilizzare SQL Server per lo sviluppo o per altre attività, sarebbe possibile eseguire quest’ultimo utilizzando una[macchina virtuale (VM)](https://it.wikipedia.org/wiki/Macchina_virtuale) o un [ambiente di containerizzazione](https://it.wikipedia.org/wiki/Virtualizzazione_a_livello_di_sistema_operativo). L’obiettivo è facilmente raggiungibile grazie a [Colima](https://github.com/abiosoft/colima), e questo articolo ti guiderà attraverso i passaggi necessari per avviare SQL Server utilizzando [Colima](https://github.com/abiosoft/colima) su macOS.

## Cos’è Colima

[Colima](https://github.com/abiosoft/colima) è un progetto Open Source che implementa un [container runtime](https://en.wikipedia.org/wiki/Open_Container_Initiative) che richiede una configurazione minima e funziona su sistemi operativi macOS e Linux. Le caratteristiche principali di questo tool sono:

- Intel and M1 Macs support
- Simple CLI interface
- Docker and Containerd support
- Port Forwarding
- Volume mounts
- Kubernetes
- Multiple instances

Colima è quindi un container runtime che esegue una VM Linux sul tuo Mac (in modo simile a come funziona [Docker Desktop](https://www.docker.com/products/docker-desktop/) per Mac). Grazie al sistema di [template](https://github.com/abiosoft/colima/blob/main/docs/FAQ.md#can-config-file-be-used-instead-of-cli-flags) (o anche da linea di comando), è possibile configurare la VM in modo tale che sia eseguita utilizzando l’[hypervisor del framework di virtualizzazione nativo in macOS](https://developer.apple.com/documentation/virtualization).

## Installazione del software

Le prime operazioni da eseguire, riguardano l’installazione di tre principali componenti software:

1. Rosetta
2. Docker CLI
3. [Colima](https://github.com/abiosoft/colima)

[Rosetta](https://it.wikipedia.org/wiki/Rosetta_(software)) è un software di emulazione sviluppato da Apple per i computer Mac con processori basati su architettura [ARM](https://it.wikipedia.org/wiki/Architettura_ARM), come il chip Apple M1. L’obiettivo principale di Rosetta è consentire l’esecuzione di applicazioni sviluppate per i processori Intel x86\_64 su Mac con processori ARM64 senza richiedere alcuna modifica da parte degli sviluppatori delle applicazioni stesse. Questa tecnologia permette agli utenti di continuare a utilizzare le loro applicazioni esistenti su nuovi Mac con processori ARM.

[Docker CLI](https://github.com/docker/cli) è uno strumento potente e flessibile che consente agli sviluppatori e agli amministratori di sistema di automatizzare il processo di creazione, gestione e distribuzione di applicazioni in container Docker.

A seguire sono indicati i comandi necessari per l’installazione dei tre componenti. Per l’installazione di Docker e [Colima](https://github.com/abiosoft/colima) è necessario che sul vostro Mac sia installato il package manager [Homebrew](https://brew.sh/).

Le versioni di riferimento di Docker e [Colima](https://github.com/abiosoft/colima), per questo articolo, sono rispettivamente: 24.0.6 e 0.5.5.

```
# Installazione di Rosetta, Docker e Colima
$ sudo softwareupdate --install-rosetta
$ brew install docker
$ brew install colima

# Verifica della versione di Docker
$ docker --version
Docker version 24.0.6, build ed223bc820

# Verifica della versione di Colima
$ colima version
colima version 0.5.5
git commit: 6251dc2c2c5d8197c356f0e402ad028945f0e830

runtime: docker
arch: aarch64
client: v24.0.6
server: v23.0.6

```

_Output 1 - Installazione del software di base necessario per l’uso di Colima_

Al fine di poter sfruttare il framework di virtualizzazione nativo di macOS in combinazione con Rosetta, è necessario che la versione di macOS sia almeno la 13.x.

## Configurazione di Colima

Una volta che l’installazione del software è stata portata a termine con successo, possiamo procedere con la configurazione della macchina virtuale che deve essere creata al fine di fornire un kernel Linux per i container specifici x86\_64 in esecuzione su macOS.

Per configurare la VM secondo le specifiche richieste per l’esecuzione di SQL Server, è possibile agire sulla configurazione della VM attraverso il meccanismo dei template (in formato [yaml](https://it.wikipedia.org/wiki/YAML)). Il template per il profilo di default è locato all’interno del folder `$HOME/.colima/_templates/default.yaml`, in ogni caso, usando il comando `colima template --print` riusciamo a ottenere il path assoluto del template di default.

I parametri da configurare sul template per la nostra specifica VM sono:

1. **vmType** : imposta il tipo di VM che in questo caso deve essere **vz** anziché quello predefinito, [qemu](https://it.wikipedia.org/wiki/QEMU). In questo modo potremo sfruttare il framework di virtualizzazione nativo di macOS (che richiede la versione 13 del sistema operativo);
2. **rosetta** : abilita Rosetta in modo che sia possibile attivare l’emulazione per architetture amd64, così come richiesto da SQL Server Server. Il valore da impostare è **true** (valido solo per Apple Silicon e vmType vz.) Il valore di default è false;
3. **mountType** : imposta il driver per il mount dei volumi. Nel caso di macOS la scelta ricade su **[virtiofs](https://virtio-fs.gitlab.io/)**, dedicato alle VM vz su macOS. Il valore predefinito è sshfs;
4. **cpu** : imposta il numero di CPU da allocare per la VM. Il valore di default è 2 ma consiglio di impostare il valore a 4;
5. **memory** : imposta la dimensione (in [GiB](https://it.wikipedia.org/wiki/Gibibyte)) da allocare per la VM. Il valore di default è 2GiB che è il [requisito minimo per l’SQL Server 2022](https://learn.microsoft.com/en-us/sql/linux/sql-server-linux-setup?view=sql-server-ver16#system), il mio consiglio è di portare il valore a 4.

Per apportare le modifiche sopra indicate alla configurazione del template, è necessario eseguire il comando `colima template`. Il comando aprirà il file yaml del template per il profilo di default (se non diversamente specificato) utilizzando l’editor di default del vostro sistema o quello impostato tramite l’environment `$EDITOR`. Nel caso in cui l’editor sia [vim](https://www.vim.org/), una volta eseguite le modifiche, usare il comando `:x` per salvare la configurazione e uscire dall’editor.

Su questo [GitHub Gist](https://gist.github.com/amusarra/9f39ee11e67f6df39eb227d2834c034e) è disponibile il file di configurazione del template completo.

Le configurazioni sopra impostate nel file del template, possono essere passate come parametri del comando `colima start`. La mia preferenza è avere questi parametri di configurazione persistenti in un file.

## Starting up Colima

Da questo momento è possibile creare la macchina virtuale dal template configurato in precedenza eseguendo il comando `colima start`.

Il comando crea e avvia una VM così come configurata in precedenza. Inoltre, modifica il contesto del comando `docker`, pertanto, quando si utilizzeranno i comandi docker, questi saranno inviati al runtime appena creato.

L’output finale che dovreste ottenere eseguendo il comando `colima start` dovrebbe essere quello indicato a seguire.

```
INFO[0000] starting colima
INFO[0000] runtime: docker
INFO[0000] creating and starting ... context=vm
INFO[0021] provisioning ... context=docker
INFO[0021] starting ... context=docker
INFO[0026] done

```

_Output 2 - Output finale a fronte dell’esecuzione del comando colima start_

Eseguendo il comando `colima status` dovreste ottenere le informazioni circa il runtime appena avviato.

L’output dovrebbe essere uguale a quello indicato a seguire a meno delle coordinate del socket.

```
INFO[0000] colima is running using macOS Virtualization.Framework
INFO[0000] arch: aarch64
INFO[0000] runtime: docker
INFO[0000] mountType: virtiofs
INFO[0000] socket: unix:///Users/<vostra-username>/.colima/default/docker.sock

```

_Output 3 - Output del comando colima status_

Eseguendo il comando `docker context list` è possibile verificare che il contesto di default sia quello di [Colima](https://github.com/abiosoft/colima) (identificato attraverso il carattere \*). A seguire l’output del comando.

```
NAME DESCRIPTION DOCKER ENDPOINT ERROR
colima * colima unix:///Users/<vostra-username>/.colima/default/docker.sock
default Current DOCKER_HOST based configuration unix:///var/run/docker.sock
desktop-linux Docker Desktop unix:///Users/<vostra-username>/.docker/run/docker.sock

```

_Output 4 - Visualizzazione dei contesti Docker con evidenza di quello attivo (in questo caso colima)_

Su [asciinema](https://asciinema.org/a/606535) è disponibile l’intero processo di starting up e verifica del runtime di [Colima](https://github.com/abiosoft/colima).

[![asciicast](https://asciinema.org/a/606535.svg)](https://asciinema.org/a/606535)

_Asciicast 1 - Processo di starting up e verifica del runtime di Colima_

## Starting SQL Server Container

Adesso che il runtime di [Colima](https://github.com/abiosoft/colima) è operativo, siamo nelle condizioni di poter creare ed eseguire il container di SQL Server a partire da una delle immagini pubblicate sull’account Docker Hub ufficiale di Microsoft. La pagina [Docker Hub](https://hub.docker.com/_/microsoft-mssql-server?tab=description) descrive nel dettaglio le modalità d’uso, i tag dell’immagini (quindi delle versioni di SQL Server) che sono disponibili su [https://mcr.microsoft.com/v2/mssql/server/tags/list](https://mcr.microsoft.com/v2/mssql/server/tags/list) e il significato dei nomi dei tag.

Per avviare una configurazione minimale di SQL Server, è possibile eseguire il comando docker indicato seguire. Nello specifico, la versione di riferimento di SQL Server è la 2022 CU7 Ubuntu 20.04. Il comando `docker run` si occuperà di eseguire il pull dell’immagine se necessario.

```
$ docker run \
 --env 'ACCEPT_EULA=Y' \
 --env 'MSSQL_SA_PASSWORD=YourStrong@Passw0rd' \
 --name 'sqlserver-2022' \
 --hostname 'sqlserver-2022' \
 --publish 1433:1433 \
 --detach \
 --platform linux/amd64 mcr.microsoft.com/mssql/server:2022-CU7-ubuntu-20.04

```

_Output 5 - Creazione e run del container SQL Server versione 2022_

Per chi ha della curiosità sull’uso dei tag, esiste questo post sul [perché il tag “latest” non vada utilizzato](https://www.theredcode.it/perch%C3%A9-il-tag-latest-non-va-utilizzato/).

Riprendendo la configurazione, a seguire è mostrato l’output che dovreste ottenere a fronte dell’esecuzione del comando precedente. La prima riga informa che l’immagine non è presente sul sistema locale e di conseguenza provvede a reperire l’immagine dal registry. Una volta completato il pull dell’immagine `mcr.microsoft.com/mssql/server:2022-CU7-ubuntu-20.04`, il container sarà creato ed eseguito; l’ultima riga mostra l’identificativo assegnato al container, ovvero, il _containerId_ (vedi riga 9 di Console 6).

```
Unable to find image 'mcr.microsoft.com/mssql/server:2022-CU7-ubuntu-20.04' locally
2022-CU7-ubuntu-20.04: Pulling from mssql/server
5b07ce5bcac1: Pull complete
b5f87f539427: Pull complete
8cf84f077c03: Pull complete
05a221025c3d: Pull complete
Digest: sha256:5362c818aad4a787e3bac20d19a2e8db7ac91cdc30b359c176bc986547b0c2d0
Status: Downloaded newer image for mcr.microsoft.com/mssql/server:2022-CU7-ubuntu-20.04
52a65e2200082558ac1accaf9ccc7d03679096a19f095b97809abfb1b7462a30

```

_Output 6 - Output del comando docker run di creazione ed esecuzione del container SQL Server_

Eseguendo il comando `docker ps -l`, dovreste vedere una serie d’informazioni circa l’ultimo container creato. A seguire un esempio dell’output.

```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
52a65e220008 mcr.microsoft.com/mssql/server:2022-CU7-ubuntu-20.04 "/opt/mssql/bin/perm…" 2 hours ago Up 2 hours 0.0.0.0:1433->1433/tcp, :::1433->1433/tcp sqlserver-2022

```

_Output 7 - Output del comando docker ps -l_

Come ultima verifica, potremmo provare a controllare il banner della versione di SQL Server eseguendo l’istruzione SQL `SELECT @@VERSION` attraverso il comando `docker exec`, così come mostrato a seguire.

```
$ docker exec -it sqlserver-2022 /opt/mssql-tools/bin/sqlcmd -S localhost,1433 -U SA -P "YourStrong@Passw0rd" -Q 'SELECT @@VERSION'

# Output del comando
Microsoft SQL Server 2022 (RTM-CU7) (KB5028743) - 16.0.4065.3 (X64)
 Jul 25 2023 18:03:43
 Copyright (C) 2022 Microsoft Corporation
 Developer Edition (64-bit) on Linux (Ubuntu 20.04.6 LTS) <X64>

(1 rows affected)

```

_Output 8 - Esecuzione dell’istruzione SQL per verificare la versione di SQL Server_

Se non diversamente specificato tramite l’environment `MSSQL_PID`, l’edizione di default è la _Developer Edition_ (vedi riga 7 del codice precedente).

Su [asciinema](https://asciinema.org/a/606537) è disponibile l’intero processo di creazione ed esecuzione del container di SQL Server e la successiva esecuzione del comando `docker exec` di verifica del banner di SQL Server.

[![asciicast](https://asciinema.org/a/606537.svg)](https://asciinema.org/a/606537)

_Asciicast 2 - Processo di creazione ed esecuzione del container di SQL Server e successiva esecuzione del comando docker exec_

## Nota personale

Per lo sviluppo software utilizzo due tipi di macchine: una [Workstation basata su AMD e Fedora Linux](https://dev.to/amusarra/la-mia-workstation-di-sviluppo-da-smart-worker-33k1) (da me assemblata) e il Mac Book Pro con macOS. Dal momento in cui ho eseguito il passaggio a Apple Silicon, sono stato costretto a trovare una soluzione che mi consentisse l’esecuzione di quei container esclusivamente compatibili con piattaforme x86. SQL Server è uno degli strumenti che uso regolarmente e compatibile solo con architetture x86 e lo stesso vale per esempio vale per Oracle Database.

[Colima](https://github.com/abiosoft/colima) è stato la mia salvezza, soprattutto per il fatto che supporta K8s e la configurazione tramite template YAML. Ho buttato via Docker Desktop (anche per via del [cambio delle politiche di licenza](https://www.docker.com/pricing/faq/)) e sostituito con [Colima](https://github.com/abiosoft/colima).

> Per chi non conosce Docker nel dettaglio o desidera approfondire l’argomento, si consiglia il libro [Docker - Sviluppare e rilasciare software tramite container](https://www.apogeonline.com/libri/docker-serena-sensini/) di [Serena Sensini](https://www.linkedin.com/in/serena-sensini/) (la versione eBook è scontata del 50% fino al primo ottobre).

# Contatti

- [Blog](https://www.dontesta.it/)
- [LinkedIn](https://www.linkedin.com/in/amusarra/)
- [E-mail](mailto:antonio.musarra@gmail.com)