WEBVTT

00:00:00.140 --> 00:00:03.020
Benvenuti a un'altra puntata di Microsoft Knowledge Nuggets su M315.

00:00:03.160 --> 00:00:04.560
FM, sono il vostro conduttore Mirko Peter.

00:00:04.960 --> 00:00:08.400
L'argomento di oggi è uno che quasi tutti hanno sentito nominare, ma che pochi sanno spiegare.

00:00:08.660 --> 00:00:09.720
Cos'è esattamente Azure DevOps?

00:00:09.980 --> 00:00:12.480
È solo uno strumento per sviluppatori o è qualcosa di molto più grande?

00:00:12.800 --> 00:00:13.740
Dunque, volete creare un software?

00:00:14.080 --> 00:00:15.760
Forse è un sito web, forse è un app mobile,

00:00:16.000 --> 00:00:18.000
o qualcosa che aiuta la vostra azienda a funzionare meglio?

00:00:18.560 --> 00:00:19.560
E vi sedete a pianificarlo?

00:00:20.000 --> 00:00:21.720
Vi serve uno strumento per tracciare le attività,

00:00:21.880 --> 00:00:23.120
un posto dove archiviare il codice,

00:00:23.240 --> 00:00:24.400
un modo per testare il lavoro,

00:00:24.800 --> 00:00:26.460
e dovete effettivamente distribuirlo agli utenti.

00:00:26.460 --> 00:00:29.260
Prima che ve ne accorgiate starete gestendo 5 strumenti diversi,

00:00:29.320 --> 00:00:30.260
di 5 aziende diverse.

00:00:31.540 --> 00:00:32.660
Uno per la gestione dell'attività,

00:00:32.980 --> 00:00:33.780
un altro per i codici,

00:00:33.860 --> 00:00:34.640
un terzo per i test,

00:00:34.700 --> 00:00:35.580
un quarto per il deployment.

00:00:36.660 --> 00:00:37.360
Un disastro.

00:00:38.040 --> 00:00:39.320
Microsoft ha osservato questo caos,

00:00:39.400 --> 00:00:40.380
ha costruito qualcosa per risolvere.

00:00:40.680 --> 00:00:41.660
Si chiama Azure DevOps

00:00:41.660 --> 00:00:43.900
e non è solo un altro strumento da aggiungere al vostro mobile.

00:00:44.320 --> 00:00:45.680
È un'unica piattaforma connessa

00:00:45.680 --> 00:00:48.040
che gestisce l'intero ciclo di vita dello sviluppo software.

00:00:48.760 --> 00:00:50.640
Pianificazione, codifica, test, rilascio,

00:00:50.900 --> 00:00:51.820
tutto è l'unico posto.

00:00:52.340 --> 00:00:53.340
Alla fine di questo episodio

00:00:53.340 --> 00:00:55.060
capirete cosa sia realmente Azure DevOps

00:00:55.060 --> 00:00:56.420
e come sui 5 elementi fondamentali,

00:00:56.460 --> 00:00:57.300
si integrino tra loro.

00:00:58.340 --> 00:00:59.720
Pensate a un moderno edificio per uffici.

00:01:00.320 --> 00:01:02.240
Word ed Excel sono le singole stanze in cui lavorate.

00:01:02.800 --> 00:01:04.600
Microsoft 365 è l'intero edificio

00:01:04.600 --> 00:01:06.160
con i suoi sistemi di sicurezza e archiviazione.

00:01:06.840 --> 00:01:08.200
Azure DevOps segue la stessa idea.

00:01:08.640 --> 00:01:10.100
È l'intero edificio per lo sviluppo software,

00:01:10.180 --> 00:01:11.200
non solo una singola stanza.

00:01:11.720 --> 00:01:13.220
Quindi cos'è esattamente Azure DevOps?

00:01:14.060 --> 00:01:15.300
Ecco la definizione più semplice.

00:01:15.700 --> 00:01:16.960
Azure DevOps è una piattaforma

00:01:16.960 --> 00:01:19.040
connessa per l'intero ciclo di vita dello sviluppo software.

00:01:19.500 --> 00:01:20.840
È una definizione complessa, quindi analizziamo.

00:01:21.260 --> 00:01:22.720
Vent'anni fa, se volevi creare un software,

00:01:22.840 --> 00:01:24.760
dovevi comprare prodotti separati per ogni cosa.

00:01:24.760 --> 00:01:26.680
Uno strumento per tracciare i bug,

00:01:27.020 --> 00:01:28.480
uno per gestire il codice sorgente,

00:01:28.600 --> 00:01:30.220
un terzo per automatizzare le build,

00:01:30.340 --> 00:01:31.120
un quarto per i test,

00:01:31.200 --> 00:01:32.140
un quinto per il deployment.

00:01:32.400 --> 00:01:34.880
Passavi metà del tempo solo a far sì che si scambiassero i dati.

00:01:35.540 --> 00:01:37.020
Microsoft ha osservato questa complessità

00:01:37.020 --> 00:01:37.580
e ha pensato,

00:01:37.660 --> 00:01:39.960
e se tutti questi servizi lavorassero insieme sotto lo stesso tempo,

00:01:40.260 --> 00:01:41.200
così hanno creato Azure DevOps.

00:01:41.580 --> 00:01:42.560
Non è un singolo strumento,

00:01:42.600 --> 00:01:43.760
ma cinque servizi che collaborano.

00:01:44.160 --> 00:01:45.480
Azure Boards per la pianificazione,

00:01:45.600 --> 00:01:46.580
Azure Repos per il codice,

00:01:46.640 --> 00:01:47.820
Azure Pipelines per l'automazione,

00:01:47.960 --> 00:01:48.960
Azure Test Plans per la qualità,

00:01:49.100 --> 00:01:50.060
Azure Test Plans per la qualità,

00:01:50.180 --> 00:01:50.700
Azure Artifact.

00:01:50.700 --> 00:01:52.120
Ognuno svolge il proprio lavoro,

00:01:52.200 --> 00:01:52.980
ma sono tutti collegati.

00:01:53.200 --> 00:01:54.920
Torniamo all'allogia dell'edificio per ufficio.

00:01:55.500 --> 00:01:56.740
La reception gestisce chi entra.

00:01:57.380 --> 00:01:58.340
Questo è il vostro servizio di dentro.

00:01:58.800 --> 00:02:00.340
Gli uffici sono i luoghi in cui le persone lavorano.

00:02:00.720 --> 00:02:01.600
Si tratta di scheda repositor.

00:02:02.100 --> 00:02:03.220
La sala posta gestisce i pack.

00:02:03.700 --> 00:02:04.480
Si tratta di artefatti.

00:02:04.760 --> 00:02:06.200
Il team di sicurezza protegge l'edificio.

00:02:06.660 --> 00:02:08.220
Si tratta dei controlli di accesso e delle policy.

00:02:08.660 --> 00:02:09.280
Ognuno ha un compito,

00:02:09.340 --> 00:02:10.420
ma sono tutti sotto lo stesso tempo.

00:02:10.780 --> 00:02:11.540
Condividono le informazioni.

00:02:12.040 --> 00:02:12.680
Lavorano insieme.

00:02:13.040 --> 00:02:13.820
E' proprio questo il punto.

00:02:14.120 --> 00:02:15.520
Ed ecco la parte migliore per i principiati.

00:02:15.740 --> 00:02:16.960
Azure DevOps ha un piano gratuito.

00:02:16.960 --> 00:02:17.960
Puoi creare un account,

00:02:18.080 --> 00:02:18.780
iniziare un progetto,

00:02:18.840 --> 00:02:20.960
usare le funzionalità principali senza pagare nulla.

00:02:21.220 --> 00:02:22.640
Cinque tenti gratuiti ottengono accesso.

00:02:22.880 --> 00:02:24.040
Un numero limitato di stakeholder

00:02:24.040 --> 00:02:25.400
ottiene un accesso limitato gratuitamente.

00:02:25.640 --> 00:02:27.500
Quindi puoi iniziare letteralmente oggi a costo zero

00:02:27.500 --> 00:02:28.560
e capire se fa il caso tuo.

00:02:29.020 --> 00:02:30.000
Nessuna carta di credito richiede.

00:02:30.340 --> 00:02:31.120
Nessuna chiamata di vento.

00:02:31.340 --> 00:02:33.380
Vai su dev.azure.com e crea un account.

00:02:33.860 --> 00:02:36.100
Quindi analizziamo i cinque servizi uno per uno iniziando.

00:02:36.540 --> 00:02:38.340
Dal luogo in cui inizia tutto il tuo lavoro.

00:02:39.320 --> 00:02:39.860
Azure Boards,

00:02:40.260 --> 00:02:41.680
il centro di comando del tuo progetto.

00:02:42.180 --> 00:02:44.300
Dunque Azure Boards è dove pianifica e monitora il tuo lavoro.

00:02:44.300 --> 00:02:46.860
Pensalo come il centro di comando del tuo progetto.

00:02:47.240 --> 00:02:49.700
Se hai mai usato post-it su una parete per tracciare le attività,

00:02:50.120 --> 00:02:51.200
conosci già l'idea di base.

00:02:52.020 --> 00:02:53.980
Ma invece di post-it fisici che cadono e si perdono,

00:02:54.080 --> 00:02:56.060
Boards ti offre una bacheca Kanban digitale

00:02:56.060 --> 00:02:58.260
che tutti nel team possono vedere e aggiornare in tempo reale.

00:02:58.880 --> 00:02:59.380
Analizziamo il dettaglio.

00:02:59.860 --> 00:03:01.120
Inizi creando elementi di lavoro.

00:03:01.740 --> 00:03:03.460
Un elemento di lavoro è qualsiasi cosa tu debba tracciare.

00:03:03.920 --> 00:03:05.340
Una user story, una funzionalità,

00:03:05.480 --> 00:03:07.280
un epic, un'attività, un bug.

00:03:08.080 --> 00:03:09.620
Ognuno ha campi per descrizione,

00:03:09.760 --> 00:03:11.400
priorità, stato e a chi ha assegnato.

00:03:11.400 --> 00:03:14.020
Organizzi questi elementi di lavoro in un backlog

00:03:14.020 --> 00:03:16.800
che è semplicemente un elenco prioritario di tutto ciò che devi fare.

00:03:17.480 --> 00:03:18.440
Puoi raggruppare in gerarchie.

00:03:18.940 --> 00:03:21.340
Epic in cima, funzionalità sotto user story sotto quelle,

00:03:21.440 --> 00:03:22.460
attività sotto le story.

00:03:23.300 --> 00:03:25.740
Ciò ti offre un quadro chiaro di cosa stai costruendo e perché.

00:03:26.460 --> 00:03:27.180
Poi per i fischi sprint.

00:03:27.580 --> 00:03:28.900
Uno sprint è un periodo di tempo fisso,

00:03:29.000 --> 00:03:30.060
solitamente di due settimane,

00:03:30.400 --> 00:03:32.860
in cui il tuo team si impegna a completare una serie di elementi di lavoro.

00:03:33.660 --> 00:03:35.500
Trascini gli elementi dal backlog in uno sprint

00:03:35.500 --> 00:03:36.740
e improvvisamente è un piano.

00:03:36.740 --> 00:03:39.560
Tutti sanno su cosa stanno lavorando e quando è la scadenza.

00:03:39.940 --> 00:03:40.560
Hai anche le query.

00:03:41.000 --> 00:03:42.840
Le query ti consentono di cercare e filtrare i tuoi eleni.

00:03:43.480 --> 00:03:45.780
Mostrami tutti i bug assegnati a Sara che hanno alta priorità.

00:03:46.240 --> 00:03:48.620
Mostrami tutte le user story in uno sprint attuale che sono ancora attive.

00:03:49.100 --> 00:03:51.440
Le query sono potenti perché trasformano i tuoi dati in risposte.

00:03:52.080 --> 00:03:54.360
Puoi salvarle, condividerle e usarle per creare dashboard.

00:03:54.780 --> 00:03:56.280
E le dashboard sono il luogo in cui tutto si unisce.

00:03:56.720 --> 00:03:58.540
Puoi creare dashboard personalizzate con widget

00:03:58.540 --> 00:04:01.420
che mostrano grafici di burn down, velocità, conteggio degli elementi di lavoro e altro.

00:04:01.420 --> 00:04:03.560
Tuo team ottene una visione in tempo reale d'avanzamento

00:04:03.560 --> 00:04:05.220
senza dover scrivere alcun rapporto di stato.

00:04:05.820 --> 00:04:06.780
Lascia che vi faccio un rapido esempio.

00:04:07.180 --> 00:04:08.700
Immagina un piccolo team che crea un sito web.

00:04:09.180 --> 00:04:11.560
Il product owner crea un'epica chiamata portale clienti.

00:04:12.660 --> 00:04:15.960
Al di sotto crea funzionalità come la registrazione utente e la cronologia ordini.

00:04:17.000 --> 00:04:19.680
Sotto la registrazione utente crea user story come

00:04:19.680 --> 00:04:22.540
come cliente voglio creare un account con la mia mail.

00:04:23.560 --> 00:04:25.720
Sotto quella storia gli sviluppatori creano dei task.

00:04:26.520 --> 00:04:27.420
Costruire il modulo di registrazione,

00:04:28.140 --> 00:04:29.340
configurare la verifica email,

00:04:29.340 --> 00:04:30.620
scrivere unit test.

00:04:31.420 --> 00:04:32.860
Ogni compito viene assegnato a qualcuno.

00:04:33.300 --> 00:04:34.920
Il team monitora i progressi sulla baghe cacca.

00:04:35.360 --> 00:04:36.920
Ognuno può vedere cosa è stato completato,

00:04:37.040 --> 00:04:38.200
cosa è in corso e cosa verrà dopo.

00:04:38.840 --> 00:04:40.820
Ora, confrontalo con l'uso di Excel o di una lavagna.

00:04:41.340 --> 00:04:42.000
Excel è statico.

00:04:42.460 --> 00:04:43.880
Invia un foglio di calcolo via email,

00:04:44.020 --> 00:04:45.340
qualcuno lo aggiorna, te lo rimanda

00:04:45.340 --> 00:04:47.060
e quando lo ricevi è già obsoleto.

00:04:47.760 --> 00:04:49.220
Una lavagna è meglio per il brainstorming,

00:04:49.280 --> 00:04:50.380
ma non è ricercabile.

00:04:50.740 --> 00:04:51.440
Non è collegata a nulla

00:04:51.440 --> 00:04:53.320
e se qualcuno cancella qualcosa è perduto per sempre.

00:04:53.780 --> 00:04:54.480
Bors è dinamico.

00:04:54.840 --> 00:04:55.300
È ricercabile.

00:04:55.640 --> 00:04:57.740
È collegato il tuo codice, i tuoi test e i tuoi rilasci.

00:04:57.920 --> 00:04:59.540
Quando qualcuno aggiorna un elemento di lavoro

00:04:59.540 --> 00:05:00.480
tutti lo vedono istantaneamente.

00:05:00.720 --> 00:05:01.760
Quindi, pianificato il lavoro,

00:05:01.980 --> 00:05:02.880
sai cosa deve essere costruito,

00:05:02.940 --> 00:05:05.040
ma ti serve un posto dove archiviare il codice vero e proprio.

00:05:05.460 --> 00:05:06.560
È qui che entra in gioco Azure Repos.

00:05:07.100 --> 00:05:09.000
Azure Repos è la casa permanente del tuo codice.

00:05:09.240 --> 00:05:10.240
Quindi, pianificato il lavoro,

00:05:10.460 --> 00:05:11.520
sai cosa deve essere costruito,

00:05:11.640 --> 00:05:13.560
ma ti serve un posto dove archiviare il codice vero e proprio.

00:05:13.860 --> 00:05:15.020
È qui che entra in gioco Azure Repos.

00:05:15.440 --> 00:05:18.060
Azure Repos offre il controllo di versione per il tuo codice utilizzando Git.

00:05:18.380 --> 00:05:19.560
Git è lo standard del settore

00:05:19.560 --> 00:05:21.380
e la maggior parte degli sviluppatori lo utilizza già.

00:05:21.740 --> 00:05:24.080
Repos ti offre uno spazio per ospitare i tuoi repository Git

00:05:24.080 --> 00:05:25.520
direttamente all'interno di Azure DevOps.

00:05:25.520 --> 00:05:27.260
Ecco l'analogia della scrittura di un...

00:05:27.260 --> 00:05:29.120
Immagina di scrivere un libro con un team di autori.

00:05:29.720 --> 00:05:31.120
Potreste scambiarvi i capitoli via mail.

00:05:31.660 --> 00:05:33.020
Qualcuno modifica il terzo capitolo,

00:05:33.100 --> 00:05:34.800
lo invia, qualcun altro lo modifica ancora

00:05:34.800 --> 00:05:36.600
e in breve tempo ti ritrovi con file

00:05:36.600 --> 00:05:40.580
chiamati capitolo 3 finale v2 inviato effettivo.docs

00:05:40.580 --> 00:05:42.800
e nessuno sa quale sia la versione corretta.

00:05:43.320 --> 00:05:44.720
Era così che appariva lo sviluppo software

00:05:44.720 --> 00:05:45.720
prima del controllo di versione.

00:05:46.140 --> 00:05:47.240
Con Git in Azure Repos

00:05:47.240 --> 00:05:49.380
tutti lavorano dallo stesso repository centrale.

00:05:50.200 --> 00:05:50.820
Tu crei un branch.

00:05:51.380 --> 00:05:53.120
Consideralo come la tua copia personale del libro

00:05:53.120 --> 00:05:55.080
dove puoi apportare modifiche senza influenzare gli altri.

00:05:55.520 --> 00:05:57.060
Scrivi il tuo capitolo, lo testi

00:05:57.060 --> 00:05:58.760
e quando sei pronto crei una pull request.

00:05:59.000 --> 00:06:01.480
È una richiesta per unire le tue modifiche nel libro principale.

00:06:02.220 --> 00:06:03.620
Altri autori revisionano le tue modifiche

00:06:03.620 --> 00:06:04.960
e lasciano commenti e individuano errori.

00:06:05.360 --> 00:06:06.400
Una volta che tutti approvano

00:06:06.400 --> 00:06:07.500
le tue modifiche vengono unite

00:06:07.500 --> 00:06:09.120
e l'intera cronologia è tracciata.

00:06:09.380 --> 00:06:10.760
Puoi vedere esattamente chi ha cambiato cosa,

00:06:10.840 --> 00:06:11.320
quando e perché.

00:06:11.860 --> 00:06:13.160
Ecco perché principianti dovrà interessare.

00:06:13.500 --> 00:06:15.100
Niente più nomi di file confusi o dubbi

00:06:15.100 --> 00:06:16.400
se stai lavorando all'ultima versione.

00:06:16.840 --> 00:06:18.200
Niente più sovrascritture accidentali

00:06:18.200 --> 00:06:18.960
del lavoro di qualcun altro.

00:06:19.300 --> 00:06:20.300
Io ti offro una rete di sicuro.

00:06:20.300 --> 00:06:22.320
Puoi sperimentare, sbagliare e tornare indietro

00:06:22.320 --> 00:06:23.220
se qualcosa si rompe.

00:06:23.640 --> 00:06:24.880
È come avere un pulsante a nulla

00:06:24.880 --> 00:06:25.900
per l'intero progetto.

00:06:26.340 --> 00:06:27.080
Ed è qui che entra in gioco

00:06:27.080 --> 00:06:28.040
il collegamento con boards.

00:06:28.580 --> 00:06:29.520
Puoi collegare i tuoi commit

00:06:29.520 --> 00:06:30.620
e le pull request direttamente

00:06:30.620 --> 00:06:31.300
agli elementi di lavoro.

00:06:31.900 --> 00:06:33.380
Quando uno sviluppatore correggio un bug

00:06:33.380 --> 00:06:35.140
include l'ID del bug nel messaggio di commit

00:06:35.140 --> 00:06:36.220
e quel commit viene collegato

00:06:36.220 --> 00:06:37.340
all'elemento di lavoro in boards.

00:06:37.980 --> 00:06:39.180
Improvvisamente ha una tracciabilità completa.

00:06:39.580 --> 00:06:40.260
Puoi vedere esattamente

00:06:40.260 --> 00:06:41.220
quali modifiche al codice

00:06:41.220 --> 00:06:41.920
sono state apportate

00:06:41.920 --> 00:06:43.280
per ogni funzionalità o correzione di bug.

00:06:43.440 --> 00:06:44.600
Product Manager possono cliccare

00:06:44.600 --> 00:06:45.500
su un elemento di lavoro

00:06:45.500 --> 00:06:46.480
e vedere il codice effettivo

00:06:46.480 --> 00:06:46.920
che è stato scritto.

00:06:47.060 --> 00:06:48.500
Gli sviluppatori possono guardare un commit

00:06:48.500 --> 00:06:49.860
e vedere a quale user story appartiene.

00:06:50.300 --> 00:06:51.020
Tutto è collegato.

00:06:51.620 --> 00:06:52.400
Quindi ora il tuo codice

00:06:52.400 --> 00:06:53.240
è archiviato e tracciato.

00:06:54.100 --> 00:06:54.660
È versionato.

00:06:54.960 --> 00:06:55.680
Ma è solo lì fermo.

00:06:55.980 --> 00:06:57.140
Come fai a farlo funzionare davvero?

00:06:57.580 --> 00:06:58.680
Come trasformi quel codice

00:06:58.680 --> 00:06:59.740
in un'applicazione funzionante

00:06:59.740 --> 00:07:00.660
che le persone possono usare?

00:07:01.040 --> 00:07:01.660
È qui che entra in gioco

00:07:01.660 --> 00:07:02.240
Azure Pipelines.

00:07:03.020 --> 00:07:03.820
Azure Pipelines

00:07:03.820 --> 00:07:04.720
il motore di automazione.

00:07:05.220 --> 00:07:05.900
Azure Pipelines

00:07:05.900 --> 00:07:06.800
è il motore di automazione

00:07:06.800 --> 00:07:07.700
che compila testa

00:07:07.700 --> 00:07:09.300
e distribuisce il tuo codice automaticamente.

00:07:09.680 --> 00:07:10.360
In parole povere

00:07:10.360 --> 00:07:11.180
prendi il tuo codice

00:07:11.180 --> 00:07:11.800
e lo trasforma

00:07:11.800 --> 00:07:12.960
in un'applicazione funzionante

00:07:12.960 --> 00:07:13.900
senza doverlo fare a mano.

00:07:14.340 --> 00:07:15.240
Pensalo come un panificio.

00:07:15.660 --> 00:07:16.860
Immagina di gestire un panificio

00:07:16.860 --> 00:07:18.060
e di cuocere ogni pagnotta a mano

00:07:18.060 --> 00:07:19.600
per ogni singolo ordine del cliente.

00:07:19.880 --> 00:07:20.320
È questo che sembra

00:07:20.320 --> 00:07:21.240
una distribuzione manuale.

00:07:21.640 --> 00:07:22.380
Qualcuno scrive il codice

00:07:22.380 --> 00:07:23.740
e tu lo copi manualmente su un server

00:07:23.740 --> 00:07:25.160
esegui manualmente la compilazione

00:07:25.160 --> 00:07:26.340
e verifichi manualmente se funziona.

00:07:26.560 --> 00:07:27.720
È lento, soggetto a errori

00:07:27.720 --> 00:07:28.800
e se ricevi molti ordini

00:07:28.800 --> 00:07:30.140
semplicemente non riesci a stare al passo.

00:07:30.620 --> 00:07:31.280
È qui che entra in gioco

00:07:31.280 --> 00:07:31.840
Azure Pipelines.

00:07:32.480 --> 00:07:33.600
Automatizzi l'intero processo.

00:07:34.080 --> 00:07:34.920
Lo configuri una volta

00:07:34.920 --> 00:07:36.220
e viene eseguito automaticamente

00:07:36.220 --> 00:07:37.680
ogni volta che qualcuno cambia il codice.

00:07:37.680 --> 00:07:39.520
Questo è chiamato CICD

00:07:39.520 --> 00:07:40.860
integrazione continua

00:07:40.860 --> 00:07:41.920
e distribuzione continua.

00:07:42.480 --> 00:07:43.200
Ecco cosa significa

00:07:43.200 --> 00:07:44.000
integrazione continua.

00:07:44.520 --> 00:07:45.500
Ogni volta che uno sviluppatore

00:07:45.500 --> 00:07:46.720
invia codice al repository

00:07:46.720 --> 00:07:48.840
la pipeline compila automaticamente

00:07:48.840 --> 00:07:50.120
l'applicazione ed esegue i test.

00:07:50.560 --> 00:07:51.360
Se qualcosa si rompe

00:07:51.360 --> 00:07:51.900
lo sai subito

00:07:51.900 --> 00:07:52.760
non due settimane dopo

00:07:52.760 --> 00:07:54.040
quando qualcuno prova a distribuire

00:07:54.040 --> 00:07:54.760
immediatamente.

00:07:55.520 --> 00:07:56.700
Lo sviluppatore viene avvisato

00:07:56.700 --> 00:07:57.480
corregge il problema

00:07:57.480 --> 00:07:58.100
e invia di nuovo.

00:07:58.740 --> 00:08:00.160
Bug vengono individuati presto

00:08:00.160 --> 00:08:00.740
quando è economico

00:08:00.740 --> 00:08:01.220
correggerli

00:08:01.220 --> 00:08:02.100
non tardi quando è costruito.

00:08:02.600 --> 00:08:03.380
La continuous delivery

00:08:03.380 --> 00:08:04.540
significa che il codice compilato

00:08:04.540 --> 00:08:04.960
e testato

00:08:04.960 --> 00:08:06.200
viene distribuito automaticamente

00:08:06.200 --> 00:08:07.100
nei tuoi ambienti.

00:08:07.100 --> 00:08:08.420
prima in un ambiente di test

00:08:08.420 --> 00:08:09.640
dove il QI può verificarlo

00:08:09.640 --> 00:08:10.620
poi in staging

00:08:10.620 --> 00:08:11.660
per i controlli finali

00:08:11.660 --> 00:08:12.120
infine

00:08:12.120 --> 00:08:12.940
in produzione

00:08:12.940 --> 00:08:14.060
dove gli utenti reali lo vedono.

00:08:14.460 --> 00:08:14.820
Ogni fase

00:08:14.820 --> 00:08:15.920
può avere approvazioni integrate.

00:08:16.400 --> 00:08:17.640
Un manager potrebbe dover approvare

00:08:17.640 --> 00:08:18.760
la distribuzione in produzione.

00:08:19.060 --> 00:08:19.720
Un responsabile QI

00:08:19.720 --> 00:08:20.900
potrebbe dover convalidare i risultati.

00:08:21.380 --> 00:08:22.720
La pipeline gestisce tutto questo

00:08:22.720 --> 00:08:24.040
con le funzionalità chiave.

00:08:24.520 --> 00:08:25.080
Hai file YAML

00:08:25.080 --> 00:08:25.460
fasi

00:08:25.460 --> 00:08:26.540
approvazioni agenti.

00:08:27.140 --> 00:08:28.480
YAML è un semplice file di testo

00:08:28.480 --> 00:08:29.540
in cui definisci la tua pipeline.

00:08:30.160 --> 00:08:31.160
Risiede nel tuo repository

00:08:31.160 --> 00:08:31.960
insieme al codice

00:08:31.960 --> 00:08:32.500
il che significa

00:08:32.500 --> 00:08:33.220
che la tua pipeline

00:08:33.220 --> 00:08:34.680
è versionata proprio come il tuo codice.

00:08:35.200 --> 00:08:36.200
Puoi vedere chi l'ha modificata

00:08:36.200 --> 00:08:36.760
quando e perché.

00:08:37.420 --> 00:08:38.240
Le fasi ti consentono

00:08:38.240 --> 00:08:39.160
di suddividere la pipeline

00:08:39.160 --> 00:08:39.860
in sezioni logiche.

00:08:40.480 --> 00:08:40.880
Compilazione

00:08:40.880 --> 00:08:41.180
test

00:08:41.180 --> 00:08:41.820
distribuzione

00:08:41.820 --> 00:08:43.020
Le approvazioni ti permettono

00:08:43.020 --> 00:08:44.060
di controllare le distribuzioni

00:08:44.060 --> 00:08:45.120
così solo le persone autorizzate

00:08:45.120 --> 00:08:45.960
possono inviare in produzione.

00:08:46.140 --> 00:08:46.940
Gli agenti sono le macchine

00:08:46.940 --> 00:08:47.600
che seguono effettivamente

00:08:47.600 --> 00:08:48.300
le tue compilazioni.

00:08:48.600 --> 00:08:50.060
Microsoft fornisce agenti ospitati

00:08:50.060 --> 00:08:51.180
oppure puoi usare i tuoi.

00:08:51.740 --> 00:08:52.320
Perché è importante

00:08:52.320 --> 00:08:52.940
per i principi anni?

00:08:53.300 --> 00:08:54.460
Perché le distribuzioni manuali

00:08:54.460 --> 00:08:55.360
sono la causa principale

00:08:55.360 --> 00:08:56.240
degli incidenti in produzione.

00:08:56.860 --> 00:08:57.940
Qualcuno dimentica un passaggio

00:08:57.940 --> 00:08:59.100
qualcuno copia il file sbagliato

00:08:59.100 --> 00:08:59.820
qualcuno distribuisce

00:08:59.820 --> 00:09:00.500
nell'ambiente errato.

00:09:00.860 --> 00:09:02.000
Le pipeline eliminano tutto questo.

00:09:02.000 --> 00:09:03.440
vengono eseguite allo stesso modo

00:09:03.440 --> 00:09:03.960
ogni singola volta.

00:09:04.360 --> 00:09:05.080
Nessun errore umano

00:09:05.080 --> 00:09:06.180
nessun passaggio è dimenticato

00:09:06.180 --> 00:09:06.640
e sono vero.

00:09:06.840 --> 00:09:07.520
Un team di cui ho letto

00:09:07.520 --> 00:09:08.060
ha visto i tempi

00:09:08.060 --> 00:09:09.000
delle distribuzioni manuali

00:09:09.000 --> 00:09:09.800
scendere da diverse ore

00:09:09.800 --> 00:09:10.820
solo di 10 o 15 minuti

00:09:10.820 --> 00:09:11.620
dopo aver configurato

00:09:11.620 --> 00:09:12.300
Azure Pipelines.

00:09:12.700 --> 00:09:13.860
Non è un piccolo miglioramento.

00:09:14.400 --> 00:09:15.120
È una trasformazione.

00:09:15.600 --> 00:09:16.220
Quindi il tuo codice

00:09:16.220 --> 00:09:16.780
viene compilato

00:09:16.780 --> 00:09:17.580
testato e distribuito.

00:09:17.820 --> 00:09:19.020
Ma prima di rilasciarlo ai clienti

00:09:19.020 --> 00:09:19.660
di rassicurarti

00:09:19.660 --> 00:09:20.420
che funzioni davvero.

00:09:20.840 --> 00:09:22.000
Non solo che venga compilato

00:09:22.000 --> 00:09:22.540
ma che faccia quello

00:09:22.540 --> 00:09:23.060
che deve fare.

00:09:23.600 --> 00:09:24.240
È qui che entra in gioco

00:09:24.240 --> 00:09:24.900
Azure Test Plans.

00:09:25.660 --> 00:09:26.440
Azure Test Plans

00:09:26.440 --> 00:09:27.880
Qualità senza tirare e indovinare.

00:09:28.220 --> 00:09:28.820
Quindi il tuo codice

00:09:28.820 --> 00:09:29.460
viene compilato

00:09:29.460 --> 00:09:29.940
e distribuito

00:09:29.940 --> 00:09:30.640
ma funziona davvero.

00:09:31.120 --> 00:09:31.960
Non solo sulla tua macchina

00:09:31.960 --> 00:09:33.040
non solo nel percorso ideale.

00:09:33.680 --> 00:09:34.460
Funziona quando qualcuno

00:09:34.460 --> 00:09:35.520
digita qualcosa di sbagliato

00:09:35.520 --> 00:09:36.280
quando la rete è lenta

00:09:36.280 --> 00:09:37.300
o quando mille persone

00:09:37.300 --> 00:09:38.440
lo usano contemporaneamente.

00:09:39.240 --> 00:09:40.140
È qui che entra in gioco

00:09:40.140 --> 00:09:40.720
Azure Test Plans.

00:09:41.100 --> 00:09:41.720
Test Plans

00:09:41.720 --> 00:09:42.580
è un modo strutturato

00:09:42.580 --> 00:09:43.700
per gestire test manuali

00:09:43.700 --> 00:09:44.460
ed esplorativi.

00:09:44.880 --> 00:09:45.660
Consideralo come la lista

00:09:45.660 --> 00:09:46.100
di controllo

00:09:46.100 --> 00:09:46.680
per valutare un pilota.

00:09:47.000 --> 00:09:47.740
I piloti non salgono

00:09:47.740 --> 00:09:48.540
semplicemente sull'aereo

00:09:48.540 --> 00:09:49.240
sperando che vada tutto.

00:09:49.600 --> 00:09:50.360
Hanno una lista di controllo.

00:09:50.640 --> 00:09:51.300
Controllano i flap

00:09:51.300 --> 00:09:52.000
il carburante

00:09:56.440 --> 00:09:57.620
Un bug in produzione

00:09:57.620 --> 00:09:58.520
può costarti denaro,

00:09:58.640 --> 00:09:59.540
clienti e reputazione.

00:10:00.360 --> 00:10:00.740
Test Plans

00:10:00.740 --> 00:10:01.640
ti fornisce questa di controllo.

00:10:01.880 --> 00:10:02.520
Ecco come funziona.

00:10:02.860 --> 00:10:03.600
Crea dei casi di test.

00:10:04.180 --> 00:10:04.940
Ogni caso di test

00:10:04.940 --> 00:10:05.820
descrive uno specifico

00:10:05.820 --> 00:10:06.500
elemento da verificare.

00:10:07.040 --> 00:10:07.960
Accedi con un nome utente

00:10:07.960 --> 00:10:08.720
e una password valida.

00:10:09.540 --> 00:10:10.160
Prova ad accedere

00:10:10.160 --> 00:10:11.140
con una password non valida.

00:10:11.900 --> 00:10:12.760
Prova a inviare il modulo

00:10:12.760 --> 00:10:13.420
senza compilare

00:10:13.420 --> 00:10:14.200
i campi obbligatori.

00:10:14.960 --> 00:10:15.700
Ogni caso di test

00:10:15.700 --> 00:10:16.300
ha dei passaggi

00:10:16.300 --> 00:10:17.160
da seguire ai risultati.

00:10:17.620 --> 00:10:18.740
Il tuo tester esegue

00:10:18.740 --> 00:10:20.060
questi casi passo dopo passo

00:10:20.060 --> 00:10:20.580
e segna ognuno

00:10:20.580 --> 00:10:21.580
come superato o fallito.

00:10:22.080 --> 00:10:22.880
Se un test fallisce

00:10:22.880 --> 00:10:23.640
è possibile segnalare

00:10:23.640 --> 00:10:24.740
un bug direttamente dal caso.

00:10:24.740 --> 00:10:26.420
Quello bug viene creato

00:10:26.420 --> 00:10:27.100
come elemento di lavoro

00:10:27.100 --> 00:10:27.620
nelle bacheche

00:10:27.620 --> 00:10:28.060
che è assegnato

00:10:28.060 --> 00:10:29.060
allo sviluppatore corretto

00:10:29.060 --> 00:10:29.960
e collegato al test

00:10:29.960 --> 00:10:31.200
per una tracciabilità completa.

00:10:31.700 --> 00:10:32.160
Puoi raggruppare

00:10:32.160 --> 00:10:32.760
i casi di test

00:10:32.760 --> 00:10:33.460
in suite di test.

00:10:33.980 --> 00:10:35.080
Magari una suite di test

00:10:35.080 --> 00:10:36.140
per il processo di checkout,

00:10:36.260 --> 00:10:37.120
un'altra per la registrazione

00:10:37.120 --> 00:10:37.560
degli utenti,

00:10:37.640 --> 00:10:38.260
un'altra per il pannello

00:10:38.260 --> 00:10:38.880
di amministrazione.

00:10:39.440 --> 00:10:40.240
Poi organizzi quelle suite

00:10:40.240 --> 00:10:40.900
in piani di test

00:10:40.900 --> 00:10:42.060
per diversi rilasci o sprint.

00:10:42.700 --> 00:10:43.460
Puoi vedere esattamente

00:10:43.460 --> 00:10:44.320
cosa è stato testato,

00:10:44.400 --> 00:10:44.960
cosa è passato,

00:10:45.060 --> 00:10:45.560
cosa ha fallito,

00:10:45.640 --> 00:10:46.100
cosa ha fallito

00:10:46.100 --> 00:10:46.800
e cosa non è ancora stato.

00:10:47.020 --> 00:10:47.940
Il collegamento alle bachecheche

00:10:47.940 --> 00:10:48.720
è ciò che lo rende potente.

00:10:48.720 --> 00:10:50.020
Quando un test fallisce

00:10:50.020 --> 00:10:50.960
crea un bug direttamente

00:10:50.960 --> 00:10:51.580
nelle bacheche.

00:10:52.180 --> 00:10:52.900
Lo sviluppatore lo vede

00:10:52.900 --> 00:10:53.380
lo corregge,

00:10:53.460 --> 00:10:54.020
invia la correzione,

00:10:54.100 --> 00:10:54.820
la pipeline compila

00:10:54.820 --> 00:10:56.020
e distribuisce la nuova versione.

00:10:56.480 --> 00:10:57.660
Il test esegue normalmente il test.

00:10:57.900 --> 00:10:58.500
Il test viene superato.

00:10:58.780 --> 00:10:59.440
Il bug viene chiuso.

00:10:59.820 --> 00:11:00.260
Tutto questo avviene

00:11:00.260 --> 00:11:01.220
all'interno di unica piattaforma.

00:11:01.500 --> 00:11:02.620
Niente mail con foglie di calcolo

00:11:02.620 --> 00:11:03.500
e niente copia di rapporti

00:11:03.500 --> 00:11:04.160
di bug tra sistemi.

00:11:04.320 --> 00:11:05.060
È tutto collegato.

00:11:05.660 --> 00:11:06.380
Sarò onesto con te.

00:11:06.620 --> 00:11:07.360
I principianti spesso

00:11:07.360 --> 00:11:08.200
trascurano test plan.

00:11:08.580 --> 00:11:09.820
I test sembrano un lavoro extra.

00:11:10.280 --> 00:11:11.380
Vuoi solo rilasciare il tuo codice?

00:11:11.940 --> 00:11:12.640
Vuoi vederlo attivo?

00:11:13.080 --> 00:11:13.520
Ma ecco il punto.

00:11:14.040 --> 00:11:15.000
Ogni singolo sviluppatore

00:11:15.000 --> 00:11:15.740
con cui ho parlato

00:11:15.740 --> 00:11:16.800
ha una storia su un bug

00:11:16.800 --> 00:11:17.580
arrivato in produzione

00:11:17.580 --> 00:11:18.640
che ha causato un disastro.

00:11:19.320 --> 00:11:20.200
Un sistema di pagamento

00:11:20.200 --> 00:11:21.260
che ha debitato i clienti due volte.

00:11:21.780 --> 00:11:22.460
Una pagina di accesso

00:11:22.460 --> 00:11:23.360
che è andata in crash sotto carri.

00:11:23.660 --> 00:11:24.300
Una funzionalità

00:11:24.300 --> 00:11:25.120
che ha cancellato i dati

00:11:25.120 --> 00:11:25.720
invece di salvato.

00:11:26.040 --> 00:11:26.960
Quei bug sono sempre quelli

00:11:26.960 --> 00:11:28.180
che avrebbero potuto essere individuati

00:11:28.180 --> 00:11:28.960
con un semplice test.

00:11:29.300 --> 00:11:30.620
Test plans è un'assicurazione economica.

00:11:30.980 --> 00:11:31.700
Richiede un po' di inizio

00:11:31.700 --> 00:11:33.340
ma ti risparmi un sacco di problemi in seguito.

00:11:34.220 --> 00:11:35.160
Man mano che il tuo team cresce

00:11:35.160 --> 00:11:36.180
incontrerai un altro problema.

00:11:36.940 --> 00:11:37.400
Inizierai a scrivere

00:11:37.400 --> 00:11:38.300
lo stesso codice più volte.

00:11:42.640 --> 00:11:44.380
e ben presto avrai 5 versioni diverse

00:11:44.380 --> 00:11:44.980
della stessa cosa

00:11:44.980 --> 00:11:46.100
tutte leggermente differenti

00:11:46.100 --> 00:11:47.300
tutte potenzialmente differenti

00:11:47.300 --> 00:11:47.840
e difettose.

00:11:48.320 --> 00:11:48.940
E' qui che entra in gioco

00:11:48.940 --> 00:11:49.520
Azure Artifacts.

00:11:50.060 --> 00:11:51.020
Azure Artifacts condividi

00:11:51.020 --> 00:11:51.920
i tuoi blocchi di costruzione.

00:11:52.420 --> 00:11:53.140
Azure Artifacts

00:11:53.140 --> 00:11:54.100
è un gestore di pacchetti

00:11:54.100 --> 00:11:55.220
per le tue librerie di codice

00:11:55.220 --> 00:11:56.340
e il modo migliore per intenderlo

00:11:56.340 --> 00:11:57.360
è paragonarlo ai mattoncini dei.

00:11:57.860 --> 00:11:58.640
Invece di costruire

00:11:58.640 --> 00:12:00.040
ogni singolo pezzo da zero ogni volta

00:12:00.040 --> 00:12:01.000
prendi blocchi già pronti

00:12:01.000 --> 00:12:01.840
e li assembli tra loro.

00:12:02.420 --> 00:12:03.400
Quando qualcuno nel tuo team

00:12:03.400 --> 00:12:04.420
crea una libreria di logging

00:12:04.420 --> 00:12:05.560
la pubblica su Artifacts

00:12:05.560 --> 00:12:06.300
e poi chiunque altro

00:12:06.300 --> 00:12:07.540
può importarla nei propri progetti

00:12:07.540 --> 00:12:08.460
con una sola riga di codice.

00:12:09.040 --> 00:12:10.000
Niente più copia di file

00:12:10.000 --> 00:12:10.780
niente invio di archivi

00:12:10.780 --> 00:12:11.480
zip via email

00:12:11.480 --> 00:12:12.000
niente dubbi

00:12:12.000 --> 00:12:13.100
su quali siano le versioni più recenti.

00:12:13.420 --> 00:12:14.400
Ecco l'analogia con il Lego

00:12:14.400 --> 00:12:15.060
più nel dettaglio.

00:12:15.480 --> 00:12:16.620
Immagina di costruire un castello.

00:12:17.100 --> 00:12:17.740
Potresti intagliare

00:12:17.740 --> 00:12:18.800
ogni singolo mattone a mano

00:12:18.800 --> 00:12:19.640
il che equivale a scrivere

00:12:19.640 --> 00:12:20.240
tutto da zero.

00:12:20.680 --> 00:12:21.620
Oppure potresti prendere

00:12:21.620 --> 00:12:22.420
mattoni già pronti

00:12:22.420 --> 00:12:23.460
e concentrarti sulle parti

00:12:23.460 --> 00:12:24.300
uniche del tuo castello.

00:12:24.640 --> 00:12:25.560
Questo è l'uso di Artifacts.

00:12:25.740 --> 00:12:27.280
I mattoni sono le tue librerie condivise

00:12:27.280 --> 00:12:28.440
il castello è la tua applicazione.

00:12:28.700 --> 00:12:29.980
Devi ancora costruire le parti uniche

00:12:29.980 --> 00:12:31.020
ma non c'è bisogno

00:12:31.020 --> 00:12:32.260
di reinventare la ruota ogni volta.

00:12:33.300 --> 00:12:34.240
Artifacts supporta

00:12:34.240 --> 00:12:35.380
diversi tipi di pacchetti

00:12:35.380 --> 00:12:36.500
Nuget per .NET

00:12:36.500 --> 00:12:37.940
NPM per JavaScript

00:12:37.940 --> 00:12:39.040
Moven per Java

00:12:39.040 --> 00:12:39.800
pacchetti Python

00:12:39.800 --> 00:12:40.780
e pacchetti universali

00:12:40.780 --> 00:12:41.620
per tutto il resto.

00:12:42.540 --> 00:12:43.100
Crea un feed

00:12:43.100 --> 00:12:44.340
che è il tuo repository privato

00:12:44.340 --> 00:12:44.860
di pacchetti

00:12:44.860 --> 00:12:45.720
e pubblichi i pacchetti

00:12:45.720 --> 00:12:46.300
al suo interno.

00:12:47.040 --> 00:12:48.120
Imposti le sorgenti upstream

00:12:48.120 --> 00:12:48.980
così puoi anche recuperare

00:12:48.980 --> 00:12:49.960
pacchetti pubblici da Nuget.

00:12:50.340 --> 00:12:51.860
Org o npmgs.com

00:12:51.860 --> 00:12:52.720
attraverso lo stesso feed.

00:12:52.940 --> 00:12:53.680
Tu hai l'unico posto.

00:12:54.000 --> 00:12:54.620
Perché è importante?

00:12:55.020 --> 00:12:55.800
Fa risparmiare tempo

00:12:55.800 --> 00:12:56.780
garantisce coerenza

00:12:56.780 --> 00:12:57.760
e gestisce le versioni.

00:12:58.260 --> 00:12:59.540
Quando aggiora una libreria condivisa

00:12:59.540 --> 00:13:00.640
pubblichi una nuova versione

00:13:00.640 --> 00:13:01.600
e i progetti che la usano

00:13:01.600 --> 00:13:02.540
possono aggiornarsi

00:13:02.540 --> 00:13:03.440
quando sono pronti.

00:13:03.880 --> 00:13:04.900
Non sono costretti ad aggiornare

00:13:04.900 --> 00:13:05.680
e non rimangono bloccati

00:13:05.680 --> 00:13:06.360
su una vecchia versione

00:13:06.360 --> 00:13:07.160
perché nessuno riesce a trovare

00:13:07.160 --> 00:13:07.960
la copia per cento.

00:13:08.000 --> 00:13:09.200
È tutto controllato e organizzato

00:13:09.200 --> 00:13:10.280
e si collega direttamente

00:13:10.280 --> 00:13:10.740
alle pipeline.

00:13:10.980 --> 00:13:12.100
La tua pipeline di compilazione

00:13:12.100 --> 00:13:13.000
può pubblicare pacchetti

00:13:13.000 --> 00:13:14.220
su Artifacts automaticamente

00:13:14.220 --> 00:13:15.400
e la tua pipeline di distribuzione

00:13:15.400 --> 00:13:16.760
può consumare pacchetti da Artifacts

00:13:16.760 --> 00:13:18.380
rendendo tutto il flusso automatizzato.

00:13:18.640 --> 00:13:19.680
Il codice viene compilato,

00:13:19.800 --> 00:13:20.200
testato,

00:13:20.300 --> 00:13:20.820
pacchettizzato,

00:13:20.940 --> 00:13:21.960
pubblicato e consumato

00:13:21.960 --> 00:13:23.080
tutto senza che nessuno

00:13:23.080 --> 00:13:24.380
debba copiare file manualmente.

00:13:24.380 --> 00:13:25.480
Quindi ora hai visto

00:13:25.480 --> 00:13:26.460
tutti e cinque i servizi.

00:13:27.020 --> 00:13:28.180
Boards per la pianificazione,

00:13:28.420 --> 00:13:29.140
repost per il codice,

00:13:29.240 --> 00:13:30.140
pipelines per l'automazione,

00:13:30.260 --> 00:13:31.000
test plans per la qualità

00:13:31.000 --> 00:13:32.500
e Artifacts per la condivisione.

00:13:32.540 --> 00:13:33.180
Ma la vera magia

00:13:33.180 --> 00:13:34.540
non sta in un singolo servizio.

00:13:35.240 --> 00:13:35.740
È nel modo in cui

00:13:35.740 --> 00:13:36.580
lavorano tutti insieme.

00:13:37.080 --> 00:13:37.660
Lascia che ti mostri

00:13:37.660 --> 00:13:38.840
come appare tutto ciò nella pratica.

00:13:39.600 --> 00:13:40.380
Il quadro generale

00:13:40.380 --> 00:13:41.520
come tutto si incastra alla perfezione.

00:13:42.080 --> 00:13:42.760
Lascia che ti mostri

00:13:42.760 --> 00:13:43.900
come appare nella pratica

00:13:43.900 --> 00:13:44.860
con uno scenario reale

00:13:44.860 --> 00:13:45.800
dove un team sta sviluppando

00:13:45.800 --> 00:13:46.520
una nuova funzionalità.

00:13:47.740 --> 00:13:48.420
Primo passaggio.

00:13:48.800 --> 00:13:49.400
Il product owner

00:13:49.400 --> 00:13:50.180
apre Azure Boards

00:13:50.180 --> 00:13:51.300
e crea una user story

00:13:51.300 --> 00:13:52.280
come e come cliente

00:13:52.280 --> 00:13:53.380
desidero poter impostare

00:13:53.380 --> 00:13:53.960
la mia password.

00:13:54.760 --> 00:13:56.100
Aggiungi criteri di accettazione.

00:13:56.280 --> 00:13:57.340
Assegnano allo sprint corrente

00:13:57.340 --> 00:13:58.300
imposto alla priorità.

00:13:58.780 --> 00:13:59.300
L'elemento di lavoro

00:13:59.300 --> 00:14:00.380
sarà ora presente nel sistema.

00:14:00.740 --> 00:14:01.480
Secondo passaggio.

00:14:01.560 --> 00:14:02.140
Lo sviluppatore

00:14:02.140 --> 00:14:03.140
apre Azure Repos,

00:14:03.340 --> 00:14:04.320
scarica l'ultimo codice

00:14:04.320 --> 00:14:05.080
e crea un nuovo branch

00:14:05.080 --> 00:14:05.840
dell'elemento di lavoro.

00:14:06.400 --> 00:14:07.300
Boards permette di farlo

00:14:07.300 --> 00:14:08.300
direttamente dalla user story.

00:14:08.680 --> 00:14:09.260
Il nome del branch

00:14:09.260 --> 00:14:10.160
include automaticamente

00:14:10.160 --> 00:14:11.280
l'ID dell'elemento di lavoro.

00:14:11.860 --> 00:14:12.500
Scrivono il codice

00:14:12.500 --> 00:14:12.960
e lo inviano

00:14:12.960 --> 00:14:14.080
e nel messaggio di commit

00:14:14.080 --> 00:14:14.520
includono

00:14:14.520 --> 00:14:15.840
FixesNumber192.

00:14:16.440 --> 00:14:16.840
Questo è il numero

00:14:16.840 --> 00:14:17.420
dell'elemento di lavoro.

00:14:17.800 --> 00:14:18.200
Il commit

00:14:18.200 --> 00:14:18.740
è ora collegato

00:14:18.740 --> 00:14:19.620
alla user story boards.

00:14:20.420 --> 00:14:21.120
Terzo passaggio.

00:14:21.200 --> 00:14:21.780
Il commit attiva

00:14:21.780 --> 00:14:22.360
automaticamente

00:14:22.360 --> 00:14:23.000
Azure Pipeline.

00:14:23.700 --> 00:14:24.500
La pipeline preleva

00:14:24.500 --> 00:14:24.980
il codice

00:14:24.980 --> 00:14:26.080
e ripristina le dipendenze

00:14:26.080 --> 00:14:26.880
e esegue la compilazione

00:14:26.880 --> 00:14:27.500
Unit Test.

00:14:28.160 --> 00:14:28.900
Se un test fallisce

00:14:28.900 --> 00:14:29.900
la pipeline si interrompe

00:14:29.900 --> 00:14:30.480
e lo sviluppatore

00:14:30.480 --> 00:14:31.380
riceve una notifica.

00:14:32.100 --> 00:14:32.900
Se tutto va a buon fine

00:14:32.900 --> 00:14:33.940
la pipeline distribuisce

00:14:33.940 --> 00:14:34.820
in un ambiente di test

00:14:34.820 --> 00:14:35.780
e lo sviluppatore

00:14:35.780 --> 00:14:36.600
può vedere il codice

00:14:36.600 --> 00:14:37.200
in esecuzione

00:14:37.200 --> 00:14:38.220
prima di chiunque altro.

00:14:39.680 --> 00:14:40.460
Quarto passaggio.

00:14:40.580 --> 00:14:41.240
Il QEngineer

00:14:41.240 --> 00:14:42.440
apre Azure Test Plans

00:14:42.440 --> 00:14:43.580
trova la suite di test

00:14:43.580 --> 00:14:44.720
per il ripristino password

00:14:44.720 --> 00:14:46.240
esegue i test manuali

00:14:46.240 --> 00:14:47.060
segue i passaggi

00:14:47.060 --> 00:14:47.600
e verifica

00:14:47.600 --> 00:14:48.700
che la funzione funzioni.

00:14:49.680 --> 00:14:50.580
Tavia trovano un bug.

00:14:51.400 --> 00:14:52.100
Messaggio di errore

00:14:52.100 --> 00:14:52.540
scritto male.

00:14:52.940 --> 00:14:53.460
Cliccano su

00:14:53.460 --> 00:14:53.960
Crea bug

00:14:53.960 --> 00:14:55.180
direttamente dal caso di test

00:14:55.180 --> 00:14:55.860
e un nuovo elemento

00:14:55.860 --> 00:14:56.760
di lavoro appare in boards

00:14:56.760 --> 00:14:58.140
collegato alla user story originale.

00:14:58.640 --> 00:14:59.440
Lo sviluppatore lo vede

00:14:59.440 --> 00:15:00.020
e lo corregge

00:15:00.020 --> 00:15:00.900
effetto il push

00:15:00.900 --> 00:15:01.860
la pipeline riparte

00:15:01.860 --> 00:15:02.260
il tester

00:15:02.260 --> 00:15:02.900
risegue il test

00:15:02.900 --> 00:15:03.740
e questo viene superato.

00:15:04.320 --> 00:15:05.040
Quinto passaggio.

00:15:05.200 --> 00:15:06.240
La funzionalità è pronta

00:15:06.240 --> 00:15:07.220
e il team pubblica

00:15:07.220 --> 00:15:08.260
la libreria di autenticazione

00:15:08.260 --> 00:15:09.520
condivisa su Azure Artifacts.

00:15:09.760 --> 00:15:10.300
Ora altri team

00:15:10.300 --> 00:15:11.040
possono utilizzarla

00:15:11.040 --> 00:15:11.560
nei loro progetti.

00:15:11.780 --> 00:15:12.240
Il componente

00:15:12.240 --> 00:15:12.780
per il ripristino

00:15:12.780 --> 00:15:13.220
della password

00:15:13.220 --> 00:15:14.200
è disponibile come pacchetto

00:15:14.200 --> 00:15:14.700
quindi ogni team

00:15:14.700 --> 00:15:15.480
che crea una funzionalità

00:15:15.480 --> 00:15:16.260
che richiede l'autenticazione

00:15:16.260 --> 00:15:17.160
puoi importarlo con una ligazione

00:15:17.160 --> 00:15:18.300
puoi importarlo con una riga di codice

00:15:18.300 --> 00:15:19.100
nessuna riscrittura

00:15:19.100 --> 00:15:19.640
nessuna copia

00:15:19.640 --> 00:15:20.260
sono un riferimento.

00:15:20.520 --> 00:15:21.740
Questa è l'integrazione completa in azione.

00:15:22.180 --> 00:15:23.040
Ogni servizio è una stanza.

00:15:23.820 --> 00:15:25.340
Boards è la sala pianificazione

00:15:25.340 --> 00:15:26.720
riposta la libreria del codice

00:15:26.720 --> 00:15:28.240
pipelines è l'area di produzione

00:15:28.240 --> 00:15:29.140
test plans

00:15:29.140 --> 00:15:30.460
la stazione di controllo qualità

00:15:30.460 --> 00:15:32.140
e Artifacts è il magazzino.

00:15:33.140 --> 00:15:33.700
Ma il vero potere

00:15:33.700 --> 00:15:34.900
non risiede in una singola stanza.

00:15:35.360 --> 00:15:35.960
Sono i corridoi

00:15:35.960 --> 00:15:36.600
che le collegano.

00:15:37.380 --> 00:15:37.980
L'elemento di lavoro

00:15:37.980 --> 00:15:38.900
si collega al codice

00:15:38.900 --> 00:15:39.980
il codice attiva la pipeline

00:15:39.980 --> 00:15:41.340
la pipeline distribuisce il test

00:15:41.340 --> 00:15:42.460
il test crea bug in boards

00:15:42.460 --> 00:15:43.140
e il pacchetto finito

00:15:43.140 --> 00:15:43.840
va in Artifacts

00:15:43.840 --> 00:15:45.620
tutto comunica con tutto il resto.

00:15:46.040 --> 00:15:47.100
E' qui che la cosa si fa interessante

00:15:47.100 --> 00:15:48.720
l'IA sta arrivando su Azure DevOps

00:15:48.720 --> 00:15:50.440
Microsoft sta implementando

00:15:50.440 --> 00:15:51.420
integrazione di Copilot

00:15:51.420 --> 00:15:52.200
come l'assistenza

00:15:52.200 --> 00:15:52.960
agli elementi di lavoro

00:15:52.960 --> 00:15:54.580
per scrivere user story migliori

00:15:54.580 --> 00:15:55.360
l'IA per riassumere

00:15:55.360 --> 00:15:56.200
lunghe discussioni

00:15:56.200 --> 00:15:57.200
e la revisione

00:15:57.200 --> 00:15:58.140
e il codice di Copilot

00:15:58.140 --> 00:15:59.200
che esamina automaticamente

00:15:59.200 --> 00:15:59.960
le pull request.

00:16:00.700 --> 00:16:01.340
E' ancora presto

00:16:01.340 --> 00:16:02.120
ma la direzione è chiara.

00:16:02.940 --> 00:16:03.960
Azure DevOps sta diventando

00:16:03.960 --> 00:16:05.040
una piattaforma intelligente

00:16:05.040 --> 00:16:06.140
non solo un insieme di strumenti.

00:16:06.460 --> 00:16:07.300
Quindi qual è il modo migliore

00:16:07.300 --> 00:16:07.740
per iniziare?

00:16:08.040 --> 00:16:08.880
Non è necessario adottare

00:16:08.880 --> 00:16:09.860
tutti e cinque servizi di nuovo.

00:16:09.860 --> 00:16:10.860
Scegliene un.

00:16:11.420 --> 00:16:12.200
Inizia con le board

00:16:12.200 --> 00:16:13.260
crea un progetto

00:16:13.260 --> 00:16:14.480
traccia alcune attività

00:16:14.480 --> 00:16:15.880
e vedi come ti trovi.

00:16:16.920 --> 00:16:17.640
Puoi aggiungere repository

00:16:17.640 --> 00:16:18.260
quando sei pronto

00:16:18.260 --> 00:16:18.880
poi le pipeline

00:16:18.880 --> 00:16:19.580
un passo alla volta.

00:16:20.300 --> 00:16:20.740
Il primo passo.

00:16:21.200 --> 00:16:22.020
Ecco l'idea centrale.

00:16:22.720 --> 00:16:23.140
Azure DevOps

00:16:23.140 --> 00:16:23.740
non è composto

00:16:23.740 --> 00:16:24.820
da cinque strumenti separati

00:16:24.820 --> 00:16:26.000
è un'unica piattaforma connessa.

00:16:26.340 --> 00:16:27.620
Boards, repos, pipelines,

00:16:27.760 --> 00:16:28.740
test plans e artifacts

00:16:28.740 --> 00:16:29.660
lavorano tutti insieme.

00:16:30.080 --> 00:16:30.560
Il valore non sta

00:16:30.560 --> 00:16:31.320
nel singolo componente

00:16:31.320 --> 00:16:32.320
ma in come si integrano tra loro.

00:16:32.520 --> 00:16:33.300
Ecco il tuo primo passo.

00:16:33.760 --> 00:16:35.200
Vai su dev.azure.com

00:16:35.200 --> 00:16:36.220
e crea un account gratuito.

00:16:36.660 --> 00:16:37.640
Poi avvia un nuovo progetto.

00:16:38.040 --> 00:16:38.700
Esplora le board

00:16:38.700 --> 00:16:39.680
crea una user story

00:16:39.680 --> 00:16:40.980
trascinala sulla Kanban board

00:16:40.980 --> 00:16:41.860
e vedi come funziona.

00:16:42.400 --> 00:16:43.040
Ecco la tua sfida.

00:16:43.540 --> 00:16:44.420
Scegli un piccolo progetto

00:16:44.420 --> 00:16:45.300
qualsiasi cosa va bene.

00:16:45.720 --> 00:16:46.420
Traccialo nelle board

00:16:46.420 --> 00:16:47.080
per una settimana

00:16:47.080 --> 00:16:47.760
aggiungi attività

00:16:47.760 --> 00:16:48.520
aggiorni allo stato

00:16:48.520 --> 00:16:49.360
e scopri cosa si prova

00:16:49.360 --> 00:16:50.280
ad avere il lavoro visibile

00:16:50.280 --> 00:16:50.880
e organizzato.

00:16:51.380 --> 00:16:52.120
Nel prossimo episodio

00:16:52.120 --> 00:16:52.600
approfondiremo

00:16:52.600 --> 00:16:53.140
azure pipelines.

00:16:53.640 --> 00:16:54.960
Costruiremo la tua prima pipeline

00:16:54.960 --> 00:16:56.440
CIS-CD passo dopo passo

00:16:56.440 --> 00:16:57.680
e vedrai come automatizzare

00:16:57.680 --> 00:16:58.960
build e deployment da zero.

00:16:59.620 --> 00:17:00.680
Iscriviti sulla tua piattaforma

00:17:00.680 --> 00:17:01.460
podcast preferita

00:17:01.460 --> 00:17:02.380
e condividi questo episodio

00:17:02.380 --> 00:17:03.020
con chi sta iniziando

00:17:03.020 --> 00:17:03.820
il proprio percorso devop.
