Durante l’ammodernamento di una webapp ASP.NET distribuita su una macchina Windows Server con IIS, abbiamo deciso (tra gli altri interventi) di aggiungere il supporto Docker per poterla distribuire in un contenitore.

L’applicazione, una volta eseguita nel container, ha iniziato però a dare problemi nelle chiamate ad alcuni servizi esterni la cui autenticazione era basata su protocollo NTLM (come ad esempio SQL Server Reporting Services).

 // ...

 var uri = new Uri("https://ssrs.intra/reports/api/V2.0");
 var networkCredential = new NetworkCredential("username", "password", "domain");

 var credentialsCache = new CredentialCache { { uri, "NTLM", networkCredential } };
 var handler = new HttpClientHandler { Credentials = credentialsCache };

 var client = new HttpClient(handler) { BaseAddress = uri };
 var response= await client.GetAsync("reports");

Tutte le chiamate, nonostante il codice tentasse correttamente una autenticazione NTLM, venivano rimbalzate con errore 401 - Unauthorized.

Ciò è dovuto all’assenza, all’interno dell’immagine Docker base utilizzata per la distribuzione, di una implementazione del security provider NTLM, non consentendo quindi all’applicativo di risolvere adeguatamente le challenge NTLM/NTLMv2.

La soluzione pertanto è stata molto semplice (molto più complesso capirla e trovarla): aggiungere all’immagine Docker il pacchetto gss-ntlmssp:

RUN apt-get update && apt-get install -y --no-install-recommends gss-ntlmssp

Approfondimenti:

• gss-ntlmssp (GitHub)
• Unable to Authenticate with NTLM from Linux with .NET 8 (StackOverflow.com)

Foto di Ian Taylor su Unsplash

L'articolo Autenticazione NTLM in container Docker Linux proviene da Alessio Marinelli.

I device utilizzati come dischi di sistema o dispositivi avviabili spesso contengono partizioni di sistema EFI che non è possibile rimuovere da Gestione Disco di Windows:

Per riutilizzare appieno questi dischi è tuttavia necessario rimuovere tutte le partizioni, crearne una grande tutto il disco e poi formattarlo a piacere.

Su Windows è disponibile l’utility da riga di comando diskpart, da lanciare tramite una console Powershell eseguita con privilegi di amministrazione:

A questo punto è possibile visualizzare un elenco dei dischi disponibili con il comando

list disk

Per selezionare il disco da cui rimuovere le partizioni, utilizzare il comando

select disk <numerodisco>

Una volta selezionato il disco, è possibile visualizzare le sue partizioni con il comando

list partition

A questo punto è possibile la singola partitzione con il comando:

select partition <numeropartizione>

ed eliminarla con il comando (NON ANNULLABILE):

delete partition override

è quindi sufficiente ripetere la stessa sequenza di comandi per tutte le partizioni, e il dispositivo sarà quindi riutilizzabile per intero direttamente da Gestione Disco.

Digita il comando exit per chiudere diskpart.

Photo by 铮 夏 on Unsplash

L'articolo Formattare un disco con partizioni EFI con Windows proviene da Alessio Marinelli.

La scorsa settimana ho recuperato un disco da 500 GB da un vecchio portatile muletto, e, volendo backupparlo prima di formattarlo, l’ho montato al volo su una macchina Windows 11 con WSL installato.

Il disco infatti ospitava una vecchia installazione di Kubuntu, per cui era formattato in formato ext4 (non direttamente leggibile da macchine Windows se non con software aggiuntivo).

Montarlo con WSL invece è facile e molto veloce. Ho infilato il disco in un case esterno USB 3.0 (uno come questo per intenderci), e in una console Powershell eseguita con diritti di amministrazione ho inserito il comando seguente per verificare come il servizio Windows Management Instrumentation vedesse il disco:

 wmic diskdrive list brief

Il disco esterno viene visto come \\.\PHYSICALDRIVE1 con 2 partizioni (nel mio caso la partizione dati era l’ultima), per cui procediamo a montarlo in WSL dalla medesima console Powershell con il comando:

wsl --mount \\.\PHYSICALDRIVE1 --partition 2

Ora che il disco è montato in WSL, è possibile aprire una console Linux WSL, e accedere al punto di mount /mnt/wsl/<mountname>, quindi nel mio caso:

Et voilà!

Tutto il disco è navigabile, ed è possibile visualizzare o copiare i file con i comandi classici Linux, ad esempio:

cp -R -v /mnt/wsl/PHYSICALDRIVE1p2/home/ /mnt/c/backup

Al termine delle operazioni, è preferibile smontare il disco da WSL (sempre da una console Powershell con diritti di amministrazione):

wsl --unmount \\.\PHYSICALDRIVE1

Photo by Aaron Boucicault on Unsplash

L'articolo Montare un disco Linux su Windows con WSL proviene da Alessio Marinelli.

Durante alcuni test con Docker e Docker Desktop, ho tentato la creazione di un progetto multi-platform con docker compose, e ho avuto qualche difficoltà.

Nel caso specifico, l’obiettivo era creare un contesto in cui il frontend Blazor fosse dockerizzato in un container Linux, mentre le API fossero servite da un progetto ASP.NET Web API (.NET Framework 4.7.2) in un container Windows, per simulare una casistica di revamping di vecchi applicativi.

Il primo passo per fare questo è verificare i prerequisiti per l’esecuzione di container Windows, e quindi configurare l’ambiente Docker per eseguirli (di default Docker Desktop imposta la modalità Linux/WSL). Modificare questa impostazione con Docker Desktop è estremamente semplice, è sufficiente cliccare di destro sulla tray icon dell’applicativo e selezionare “Switch to Windows containers”.

Dopo un po’ di rimuginamenti, Docker Desktop va in errore, e si pianta con un messaggio abbastanza sibillino:

Something went wrong - Post "http://ipc/windowsfeatures/check": open \\.\pipe\dockerBackendV2: The system cannot find the file specified.

Anche l’esecuzione da riga di comando del client con log verboso non dà molte informazioni in più:

> cd "C:\Program Files\Docker\Docker"
> .\DockerCli.exe -Verbose
[2024-10-04T12:18:39.554157800Z][DockerCli.exe.ipc][I] ipc.NewClient: dcfbb6ca-docker-cli -> \\.\pipe\dockerBackendApiServer BackendAPI

Ho tentato anche di tornare ai container Linux, sia da tray icon, che da CLI, senza successo (sempre stesso errore):

> ./DockerCli.exe -SwitchLinuxEngine

Alla fine mi sono rassegnato, e ho proceduto ad una reinstallazione pulita di Docker Desktop (con rimozione della cartelle %AppData%\Docker e %UserProfile%\.docker). Questo ovviamente ha comportato l’eliminazione di tutti i container e le immagini scaricate.

Una volta completata la reinstallazione, da tray icon sono riuscito a configurare la modalità Windows containers.

L'articolo Docker Desktop bloccato durante passaggio a Windows container proviene da Alessio Marinelli.

Una delle cose che apprezzo di più della virtualizzazione con Docker, è la possibilità di creare ambiente di sviluppo e test ordinati e replicabili con pochissimo sforzo, senza dover installare nulla.

Inoltre, lavorando su progetti e stack diversi, è spesso necessario che nella macchina di sviluppo convivano versioni diverse dello stesso servizio o dello stesso database server, cosa che diventa quasi impossibile installando direttamente tali prodotti.

Docker di fatto risolve tutti questi problemi, e anche tirare su un database server di classe enterprise come Microsoft SQL Server è semplice come digitare questo comando nella shell:

docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=<password_sa>" -p 1433:1433 --name sql-2022 --hostname sql-2022 -v /mnt/c/SqlServerData:/var/opt/mssql/data -u root -d mcr.microsoft.com/mssql/server:2022-latest

Questo comando chiede a Docker di:

• Utilizzare un’immagine di SQL Server 2022 ultima versione
• Eseguire il database server con il nome host “sql-2022”
• Impostare la password dell’utente SA
• Montare una cartella locale come volume persistente per ospitare i file dei database creati

In pochi istanti avrete tutto pronto per iniziare a lavorare sul database server.

È anche possibile creare un file YAML docker-compose per evitare ogni volta di dover inserire un comando così lungo, per orchestrare il database con altri container o per inserire configurazioni più raffinate:

version: '3.9'
services:
    sql-2022:
        container_name: sql-2022
        hostname: sql-2022
        image: mcr.microsoft.com/mssql/server:2022-latest
        user: root
        volumes:
            - /mnt/c/SqlServerData/data:/var/opt/mssql/data
            - /mnt/c/SqlServerLog:/var/opt/mssql/log
            - /mnt/c/SqlServerSecrets:/var/opt/mssql/secrets
        ports:
            - 1433:1433
        environment:
            - ACCEPT_EULA=Y
            - MSSQL_SA_PASSWORD=<password>
            - MSSQL_PID=Express
        restart: unless-stopped
        healthcheck:
            test:
                [
                    "CMD-SHELL",
                    "/opt/mssql-tools/bin/sqlcmd -S localhost -U sa -P <password> -Q 'SELECT 1' || exit 1"
                ]
            interval: 10s
            retries: 10
            start_period: 10s
            timeout: 3s

Il file YAML così creato è eseguibile in maniera molto più semplice inserendo da shell il seguente comando:

docker-compose -f file.yml up

In aggiunta a quanto visto per il comando diretto, in questo esempio docker-compose ho aggiunto:

• La mappatura dei volumi per ospitare i log e i secrets
• Il riavvio automatico del server (se dovesse crashare o riavviarsi per qualsiasi motivo)
• L’utilizzo della versione Express di SQL Server 2022
• Un controllo healtcheck per permettere a docker-compose di valutare lo stato di salute del container, e intraprendere azioni qualora sia degradato

In questo caso specifico il controllo healtcheck utilizza l’utility sqlcmd per lanciare una semplicissima query ad intervalli regolari di 10 secondi; nella colonna Status dei processi Docker attivi è ora visualizzato anche lo stato di salute del container, e non solo l’uptime/downtime.

Approfondimenti

• Quickstart: Run SQL Server Linux container images with Docker (learn.microsoft.com)
• Configure and customize SQL Server Docker containers (learn.microsoft.com)
• Restore a SQL Server database in a Linux container (learn.microsoft.com)
• Docker Compose file version 3 reference – HEALTCHECK (docs.docker.com)
• Microsoft SQL Server – Ubuntu based images (mcr.microsoft.com)

Photo by Paul Teysen on Unsplash

L'articolo Eseguire SQL Server in Docker proviene da Alessio Marinelli.

Nuova versione dalla mia libreria Italian Toolkit, che con il rilascio 1.2 aggiunge un validatore formale delle targhe automobilistiche italiane attualmente in corso di validità.

La validazione è formale (ovvero ne viene verificata la correttezza strutturale, non se il veicolo è effettivamente esistente o registrato al PRA), e sono supportate tutte le principali tipologie di targhe, incluse quelle dei veicoli delle Forze dell’Ordine, delle Forze Armate e dei Corpi Diplomatici e Consolari.

Il codice sorgente è disponibile qui, mentre su NuGet trovate già il pacchetto pronto per l’utilizzo.

Photo by Jay Zhang on Unsplash

L'articolo Italian Toolkit 1.2 – Riconoscimento delle targhe automobilistiche italiane proviene da Alessio Marinelli.

Alcuni contesti applicativi richiedono l’esecuzione di processi di sistema o console application per assolvere alle funzioni richieste dall’utente, e talvolta è necessario impacchettare tali funzionalità all’interno di una REST API.

Ad esempio potremmo essere di fronte ad un revamping di funzionalità fornite da console application o da software on-premise, o potrebbero esserci contesti operativi in cui si vogliono utilizzare programmi di terze parti distribuite direttamente in formato eseguibile.

Qualsiasi sia il vostro contesto operativo, è molto semplice inglobare tali software all’interno di una API, utilizzando le classi messe a disposizione dal namespace System.Diagnostics e redirigendo i flussi standard di input, output ed errore.

L’esempio che ho pubblicato su Github è ispirato da un post di qualche settimana fa di Marco Giannini sul suo blog Marco’s Box, che spiegava come utilizzare fortune per stampare nella CLI Linux delle piccole perle di saggezza, personalizzabile anche con dizionari custom.

I punti di interesse di questo progetto di esempio sono due: come utilizzare un processo di sistema (in questo caso fortune con dizionari personalizzati in un container Debian) e come aggiungere applicazioni nel container Docker che ospita l’applicativo.

Eseguire un processo di sistema all’interno di una Web API C#

Esattamente come nei contesti più classici (console application e applicazioni desktop), per eseguire un processo di sistema è sufficiente istanziare un nuovo oggetto System.Diagnostics.ProcessStartInfo in cui inserire tutti i parametri del processo da lanciare, e su cui configurare il redirect dei flussi standard di input, output ed errore:

// https://github.com/Defkon1/pikaquote/blob/main/Pikaquote/Pikaquote.Core/Services/QuotesService.cs

try
{
    var psi = new ProcessStartInfo()
    {
        FileName = "/usr/games/fortune",
        Arguments = argument,
        UseShellExecute = false,
        RedirectStandardInput = true,
        RedirectStandardOutput = true,
        RedirectStandardError = true
    };

    using (var process = Process.Start(psi))
    {
        errors = await process.StandardError.ReadToEndAsync();

        results = await process.StandardOutput.ReadToEndAsync();
    }

    return new QuoteDto()
    {
        CreatedAt = DateTime.UtcNow,
        Message = results,
        UsedDictionary = supportedDictionary?.Name ?? _supportedDictionaries.First(d => string.IsNullOrEmpty(d.Slug)).Name
    };
}
catch (System.ComponentModel.Win32Exception exception)
{
    _logger.LogError(exception, message: errors);
}
catch (Exception exception)
{
    _logger.LogError(exception, "Unknown error");
}

In questo caso il processo di fortune è installato in /usr/games/fortune e prende come argomento l’eventuale dizionario personalizzato da utilizzare; il risultato (la perla di saggezza) viene recuperata redirigendo lo standard output, mentre gli eventuali errori vengono catturati direttamente dallo standard error.

Il risultato viene impacchettato in DTO di risposta e restituito al controller. Semplice e veloce.

Aggiungere applicazioni di sistema nel container Docker Web API

L’immagine di default utilizzata da ASP.NET Core (nel caso mostrato basata su Debian) non include fortune out-of-the-box, per cui ho modificato il DockerFile per fare nell’ordine:

• aggiungere contrib all’elenco sorgenti
• installare i pacchett fortune-mod, wget e dos2unix
• scaricare da PasteBin i dizionari personalizzati citati nell’articolo di Marco Giannini con wget
• convertire i line break dei file scaricati da formato DOS a formato Unix con dos2unix
• trasformare i file di testo scaricati in dizionari per fortune con strfile (incluso nel pacchetto fortune-mod)

Tutte queste operazioni sono facilmente eseguite mediante comandi RUN direttamente nel DockerFile sull’immagine base:

RUN sed -i'.bak' 's/$/ contrib/' /etc/apt/sources.list
RUN apt-get update && apt-get install -y fortune-mod
RUN apt-get install -y wget
RUN apt-get install -y dos2unix
RUN wget --no-check-certificate https://pastebin.com/raw/p296KDcE -O /usr/games/fortune-devops
RUN dos2unix /usr/games/fortune-devops
RUN strfile /usr/games/fortune-devops

In questo modo il container risulta essere già pronto con tutti gli strumenti necessari all’invocazione del processo dall’interno dell’API.

Il codice sorgente completo dell’esempio è disponibile su Github con licenza MIT: https://github.com/Defkon1/pikaquote/ (la stellina è sempre gradita)

Have fun!

L'articolo Eseguire processi di sistema in una Web API C# proviene da Alessio Marinelli.

Nuova versione dalla mia libreria Italian Toolkit, che con il rilascio 1.1.1 aggiunge il supporto SPERIMENTALE all’Identificativo Unico Nazionale (ID ANPR), che sostituirà nel medio periodo l’uso del codice fiscale.

L’Identificativo Unico Nazionale è stato definito con Decreto Ministeriale del 03/03/2023 pubblicato in Gazzetta Ufficiale s.g. 91 del 18/04/2023, ma il suo supporto è marchiato come SPERIMENTALE perché attualmente non è stato ancora pubblicato il documento tecnico ufficiale sulle modalità di calcolo del nono carattere (check digit). L’algoritmo utilizzato sembra essere un Luhn mod N, ma la libreria si basa attualmente sul reverse engineering del calcolo (e numerose prove empiriche).

Per maggiori dettagli sull’algoritmo utilizzato e sull’ID ANPR, vi rimando all’issue aperto nel repository.

Il codice sorgente è disponibile qui, mentre su NuGet trovate già il pacchetto pronto per l’utilizzo.

Photo by Jay Zhang on Unsplash

L'articolo Italian Toolkit 1.1.1 – Supporto all’Identificativo unico nazionale (ID ANPR) proviene da Alessio Marinelli.

Talvolta sulle piattaforme di sharing video vengono pubblicati video (tutorial, concerti, …) di cui si vorrebbe estrarre l’audio e magari separarlo in più tracce per un ascolto offline più agevole.

Ci sono decine di prodotti commerciali utili allo scopo, ma in realtà possiamo procedere da riga di comando con il solo ausilio di ffmpeg. Vediamo come!

1. Ottenere il file originale

Il primo passo è ovviamente ottenere il file originale; ad esempio è possibile utilizzare un altro tool da riga di comando come youtube-dl per scaricare direttamente il contenuto audio in formato MP3:

youtube-dl --ignore-errors --no-check-certificate --format bestaudio --extract-audio --audio-format mp3 --audio-quality 160K --output "%(title)s.%(ext)s" https://<url_del_video>

Se preferite utilizzare un programma con GUI, vi consiglio l’ottimo jDownloader.

2. Convertire il file originale da MP4 in MP3

Qualora abbiate disponibile il file video (ad esempio in formato MP4), è sempre possibile estrarre la traccia audio proprio con l’aiuto di ffmpeg:

ffmpeg -i <file_sorgente>.mp4 <file_destinazione>.mp3

Nota bene: ffmpeg è un tool potentissimo e ogni comando ha decine di parametri; nel caso sopra provvederà a tentare l’autoriconoscimento dei formati coinvolti, ma vi consiglio di visionare la documentazione ufficiale per maggiori dettagli sui parametri disponibili.

3. Tagliare il file MP3 in multiple tracce

Una volta ottenuto il file MP3 sorgente, dovrete decidere in quali punti tagliare.

Ad esempio, potremmo avere un video tutorial da dividere in 5 tracce a questi minutaggi:

• 00:00:00 Introduzione
• 00:10:21 Capitolo 1
• 00:38:34 Capitolo 2
• 00:52:13 Capitolo 3
• 01:08:35 Conclusioni

Il comando per tagliare una singola traccia in ffmpeg è abbastanza semplice; la prima traccia sarebbe ad esempio estraibile nel seguente modo:

ffmpeg -ss 00:00:00.0 -i <file_da_tagliare>.mp3 -acodec copy -t 00:10:21.0 <traccia_1>.mp3

Oppure potreste usare questo comodo script CLI per tagliarle tutte insieme:

source="source audio <file_da_tagliare>.mp3"; i=0; t1=0:00; for end_time in 10:21 38:34 52:13 1:08:35 ''; do i=$((i+1)); t0=$t1 t1=$end_time; echo ffmpeg -i "$source" -acodec copy -ss $t0 ${t1:+-to} $t1 $(printf "track%02d.%s" $i ${source##*.}); done

4. Aggiungere i tag

Se volete “lavorare di fino”, potete poi rinominare i file tagliati e aggiungerci i metadata, ad esempio utilizzando Mp3tag.

Enjoy!

Photo by C D-X on Unsplash

L'articolo Tagliare un MP3 da riga di comando proviene da Alessio Marinelli.

È una piccola libreria che contiene una serie di metodi helper e classi utility per la gestione e validazione di dati di uso comune quando si lavora nel contesto italiano, come ad esempio codici fiscali, targhe automobilistiche e unità territoriali (regioni, province, comuni e aree metropolitane).

Al momento nella versione 1.0.1 sono disponibili i seguenti metodi per la gestione dei codici fiscali:

• Validazione formale dei codici fiscali (standard e temporanei)
• Calcolo del codice fiscale a partire dai dati anagrafici
• Calcolo delle omocodie a partire dal codice fiscale standard
• Validazione di un codice fiscale omocodo

La libreria ha come target .NET Standard 2.0 per essere il più trasversale possibile, ed è installabile da NuGet tramite il Package Manager o da riga di comando:

dotnet add package ItalianToolkit

Il codice sorgente è disponibile con licenza MIT su GitHub all’indirizzo https://github.com/Defkon1/italian-toolkit ed è aperto a discussioni e contributi.

Italian Toolkit partecipa al GitHub + DEV 2023 Hackaton e al suo interno è possibile vedere l’utilizzo di GitHub Actions per la pubblicazione automatica, per l’aggiornamento del README e per l’analisi del codice (CodeQL e Linter).

Per maggiori dettagli (come contribuire, roadmap delle prossime implementazioni, …) andate direttamente sul repository https://github.com/Defkon1/italian-toolkit!

Voglio ringraziare tutta la community italiana di .NET ed in particolare Marco Minerva per il suo continuo ed instancabile lavoro di diffusione di contenuti!

Photo by Jay Zhang on Unsplash

L'articolo Italian Toolkit – developizza e maindolino proviene da Alessio Marinelli.