Latest / M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano / Registrare funzionalità Copilot personalizzate in Business Central: AL, metaprompt e chiavi Azure OpenAI sicure (Doppiaggio IA)

Transcript

Registrare funzionalità Copilot personalizzate in Business Central: AL, metaprompt e chiavi Azure OpenAI sicure (Doppiaggio IA) · M365.FM – Podcast su Microsoft 365, Copilot e IA in italiano

0:00
Hai mai desiderato che Business Central sbrigasse al posto tuo le attività noiose?
0:03
Come riconciliare pagamenti o scrivere descrizioni di prodotti,
0:06
invece di sommergerti di clic extra e notate di sofferenza su Excel?
0:09
Questa è la promessa di Copal.
0:11
E prima che tu lo chieda, sì, è integrato in Business Central online senza costi aggiuntivi,
0:15
ma non aspettarti che funzioni sulla tua installazione on-premise.
0:18
Ecco il punto.
0:19
La maggior parte degli amministratori non va oltre le demo preconfezionate.
0:22
Oggi analizzeremo tutto nel dettaglio per mostrarti come far funzionare Copal e tua azienda.
0:26
Alla fine avrai una lista di controllo da testare nel tuo ambiente sandbox.
0:30
E tutto inizia dal menu nascosto di cui Microsoft parla malapena.
0:33
Il menu segreto di Copilot, il vero potere di Copilot,
0:36
non risiede nei pulsanti appariscenti che vedi sulla scheda cliente.
0:39
Il vero trucco è ciò che Microsoft ha lasciato sotto la superficie.
0:42
Troverai quei punti di estensione all'interno dello spazio dei nomi System AI,
0:45
cerca la code unit Copilot Capability e i relativi Enum.
0:48
È lì che risiedono i veri ganci per i sviluppatori.
0:50
Non si tratta di artefatti casuali nei codici sorgere.
0:52
Sono stati creati per permetterti di definire e registrare le tue funzioni basate sull'IA,
0:56
invece di aspettare che Microsoft rilasci una nuova demo ogni trimestre.
1:00
Il menu con cui interagiscono quasi tutti è solo la superficie.
1:03
Inserisci dati di fatturazione, tieni un riepilogo pulito, magari scrivi una descrizione prodotto.
1:07
Ma quelli sono scenari dimostrativi per dire guardate funziona.
1:10
In realtà, le viscere di Business Central contengono oggetti come Copilot Capability e Copilot Availability.
1:15
In parole povere, la Capability è l'insieme di abilità che stai creando per Copilot.
1:20
La Availability dice al sistema quando e dove quell'abilità deve apparire per gli utenti finali.
1:25
Insieme, non sono solo un menu di widget e apre confezionati.
1:28
Sono un framework per rendere Copilot specifico per la tua azienda.
1:31
Ecco il punto cruciale.
1:32
Molti amministratori pensano che Copilot sia completamente blindato come una scatola nera luce.
1:36
Usano ciò che ci alzano e le spalle vanno avanti.
1:38
Non vanno mai a cercare controlli extra.
1:40
Ma a livello di sviluppatore hai diverse levi a disposizione.
1:42
Sì, esiste un modo per gli amministratori di vedere i risultati di ciò che gli sviluppatori registrano.
1:47
Vai alla pagina funzionalità Copilot e agente dentro Business Central.
1:50
Ogni funzionalità che registri appare lì.
1:53
Gli amministratori possono disattivarle una per una se qualcosa non funziona bene.
1:56
Quella connessione gli sviluppatori definiscono nella linea L, gli amministratori gestiscono nell'interfaccia
2:00
e il ponte che rende tutto questo più che pura teoria.
2:03
Non pensarlo come un dispositivo Apple bloccato ma piuttosto come una console con comandi di debug nascosti.
2:08
Se tutto ciò che fai è cliccare sul pulsante principale di Copilot e sprecando un sacco di potenziale.
2:12
È come guidare una Tesla e avanzare solo a passo d'uomo nel traffico.
2:15
L'interruttore della modalità Ludiclus esiste, ma finché non lo aziona resta girare a vuoto.
2:20
La stessa cosa qui.
2:21
Gli oggetti dello spazio dei nomi sono già nel tuo tenant, ma se non sai dove guardare, non li userai mai.
2:25
Quindi di quanta potenza stiamo parlando?
2:28
Il modulo I all'interno di Business Central offre completamente di testo,
2:31
completamente in stile chat per flussi di lavoro e embedding per la ricerca semantica.
2:35
Ciò significa che puoi costruire una funzionalità che ad esempio redige ordini di acquisto
2:39
basati sui modelli della tua azienda invece che sulle ipotesi di Microsoft.
2:42
Significa anche che puoi creare assistenti che parlano con la voce della tua azienda,
2:46
non come una sterile circolare delle risorse umane.
2:48
È una breve nota prima che qualcuno si faccia stranetto.
2:50
La funzione di anteprima della chat con Copilot che potresti aver visto in Business Central
2:53
non è estendibile tramite questo modulo.
2:55
Quella chat segue una propria strada.
2:56
Ciò che puoi estendere avviene tramite il modello di capacità descritto qui.
3:00
Microsoft non è stata molto brava a far emergere questo aspetto nel suo mago.
3:03
Sia nei documenti, ma sepolto in una sezione tecnica arida che pochi amministratori leggono.
3:06
Ma una volta che sai che questi oggetti esistono in quadro campo.
3:09
Ogni stranezza finanziaria, ogni bizzarro campo personalizzato,
3:12
ogni complesso flusso di approvazione,
3:14
tutto può essere gestito con la tua funzionalità Copilot.
3:17
Invece di aspettare che Redmond cali qualcosa dall'alto,
3:19
puoi adattare l'assistente direttamente al tuo ambiente.
3:23
Naturalmente nulla di così potente arriva senza etichette di avvertenza.
3:25
Questi sono strumenti affidati.
3:26
Registrare le funzionalità in moderato può creare conflitti,
3:29
specialmente quando Microsoft rilascia aggiornamenti.
3:31
Se sbagli, all'improvviso, sandbox si rompe o, peggio, blocchi gli utenti in produzione.
3:35
Ecco perché la pagina delle funzionalità di Copilot è degli agenti importanti.
3:39
Non solo offre visibilità agli amministratori,
3:40
ma ti dà un interruttore di arresto rapido
3:41
se il tuo cervello personalizzato inizia a comportarsi male.
3:44
Quindi il vantaggio qui è semplice.
3:46
Sì, c'è un menu segreto sotto Copilot.
3:48
Sì, è già presente in ogni tenant.
3:49
E sì, trasforma Copilot da un giocattolo dimostrativo in qualcosa di utile,
3:52
ma sapere che esiste è solo il primo passo.
3:54
Il vero trucco è registrare quelle funzionalità in modo sicuro,
3:57
così da aggiungere potenza senza bruciare il tuo ambiente.
4:00
Ed è qui che andremo dopo.
4:03
Registrare senza bruciare il tuo tenant.
4:05
Registrare una funzionalità Copilot non è un vago trucco magico.
4:09
In termini semplici a L significa creare un'estensione enum
4:11
per l'enum della funzionalità Copilot
4:13
e poi usare una code unit di installazione e aggiornamento
4:15
che chiama la funzionalità Copilot.
4:17
Registra funzionalità.
4:18
È la stretta di mano con cui dice Business Central.
4:21
Ecco una nuova funzione IA.
4:22
Trattala come parte del sistema.
4:23
Senza quella chiamata la tua estensione potrebbe compilarsi
4:26
ma Copilot non saprà nemmeno che la funzione esiste.
4:28
Immaginala come la presentazione di documenti per il risorso no.
4:31
Nessun record nell'organigramma, nessuna scrivania, nessuna email, nessun dipendente.
4:35
Una volta definita la base, il dettaglio successivo riguarda ambito e nomenclatura.
4:39
Ogni funzionalità che registri vive nello stesso ecosistema
4:42
che Microsoft aggiorna costantemente.
4:44
Se ricicli un nome generico o riservi un ID approssimativo
4:46
stai praticamente cercando un conflitto.
4:48
Diciamo che la chiami Sales Helper e la contrassegni con un valore enum.
4:51
Poi Microsoft rilascia un futuro aggiornamento con una funzionalità integrata nello stesso spazio.
4:56
All'improvviso il sistema non sa quale mostrare
4:57
e tuo codice va in conflitto con Redmond durante l'esecuzione.
5:00
La soluzione è noiosa ma è essenziale.
5:02
Scegli i nomi univoci e assegni ai tuoi valori enum
5:04
che non si sovrappongono a quelli comuni
5:05
e dai una versione deliberata all'intera estensione.
5:08
Aggiungi i numeri di versione per monitorare
5:09
se il sandbox è alla 1.2
5:11
mentre la produzione è ancora alla 1.0.
5:13
E se qualcosa cambia nella piattaforma
5:15
le tue code unit di aggiornamento
5:16
sono lo strumento per portare avanti la funzionalità in sicurezza.
5:19
Senza di quelle stai attaccando con il nastro adesivo
5:21
nuovi cavi in un vecchio quadro elettrico
5:23
sperando che nulla prenda fuoco.
5:24
Ecco dove troppi sviluppatori diventano superficiali.
5:27
Pubblicano l'estensione direttamente in produzione
5:28
perché ha solo una funzionalità.
5:30
È lì che il tuo plasco viene preso da sempre.
5:31
Il percorso corretto è semplice.
5:33
Prima sono in sandbox.
5:35
Rompi, la rifattorizza, la testala di nuovo
5:36
e solo quando funziona correttamente passa la produzione.
5:39
Quello rilascio controllato riduce le sorprese.
5:41
E non si tratta solo di compilare codice,
5:42
si tratta di governance.
5:44
La pagina delle funzionalità di Copilot
5:45
e degli agenti in Business Central
5:46
funge anche da controllo di validità.
5:48
Se la tua funzionalità non appare lì dopo la registrazione
5:51
non è registrata correttamente.
5:53
Quella pagina riflette dal sistema.
5:54
Solo dopo averla validata lì
5:56
dovresti consegnarla per la revisione dell'amministratore.
5:58
E a proposito di amministratori
5:59
attivare e disattivare le funzionalità di Copilot
6:02
oltre a configurare il movimento dei dati
6:03
è qualcosa che possono fare solo gli amministratori
6:05
con super permessi un ruolo di amministratore di Business Central.
6:09
Pianifica questo passaggio di governance in antico.
6:11
Un rapido consiglio
6:12
quando registri user parametro opzionale
6:13
LearnMoreURL.txt
6:15
Questo apparirà direttamente nella pagina di amministrazione
6:18
delle funzionalità di Copilot e degli agenti.
6:20
Non è solo un tocco di classe, documentazione integrata.
6:23
Invece di far cercare agli amministratori
6:24
un link wiki o disturbarti su Teams
6:26
possono cliccare direttamente sulla descrizione
6:28
di cosa fa la funzionalità e come usarla.
6:30
Immaginano come scrivere le istruzioni
6:31
direttamente sull'interruttore della luce
6:33
così la persona successiva non premerà quello sbagliato.
6:35
Ecco una lista di best practice che riduce i rischi.
6:38
Primo, esegui tutto in un ambiente sandbox
6:39
prima della produzione.
6:40
Secondo, scegli valori enum
6:42
univoci ed evita intervalli comuni.
6:44
Terzo, usa sempre unità di aggiornamento
6:45
di installazione per percorsi puliti.
6:48
Quarto, lega l'URL di approfondimento
6:49
così gli amministratori non dovranno tirare a indovinare.
6:51
Segui queste quattro regole
6:52
e manterrai il tuo tennis double.
6:54
Ignorale e ti ritroverai a ripristinare database
6:58
il parcheggio è ancora valida.
6:59
Registrare una funzionalità
7:00
è come riservare ufficialmente un posto
7:02
per la tua nuova auto.
7:03
Compila la documentazione corretta
7:04
sarà tua e tutti saranno feliti.
7:06
Salta il processo, parcheggia in zona rossa
7:08
e bloccherai l'accesso ai vigili del fuoco
7:09
facendo arrabbiare tutti.
7:10
La registrazione serve a creare
7:12
uno spazio sicuro per la tua funzionalità
7:13
affinché Business Central e aggiornamenti Microsoft
7:15
possano coesistere a lungo.
7:17
In sintesi, tratta la registrazione
7:18
come codice di produzione
7:19
perché è esattamente ciò che è.
7:21
Testa in sandbox, mantieni il tuo scopo univo
7:23
e traccia le versioni in direttuità
7:24
di codice di aggiornamento a prova di errore.
7:26
Se succede qualcosa di strano
7:27
la pagina delle funzionalità di Copilot
7:28
e degli agenti
7:29
insieme al tuo URL di approfondimento
7:30
permetteranno agli amministratori
7:31
di trovare e capire
7:32
se è necessario disattivare la funzione.
7:34
Fatta bene, la registrazione garantisce stabilità.
7:37
Fatta male, ti prepara al caos.
7:39
Una volta consolidato questo aspetto
7:41
noterei che la funzionalità
7:42
è operativa ma generica.
7:44
Risponde ma senza carattere.
7:45
È come assumere una persona brillante
7:47
che si presenta alle riunioni.
7:48
Passo successivo è insegnare al tuo Copilot
7:50
come comportarsi
7:51
perché altrimenti suonerà meno come un assistente fidato
7:53
più come un adolescente
7:54
che alza gli occhi al cielo
7:55
davanti alle tue domande.
8:06
Nella documentazione per sviluppatori Microsoft
8:08
un metaprompt è il messaggio di sistema principale
8:10
che definisce il profilo del modello
8:11
il formato di output e linee guida.
8:14
In parole semplici
8:14
c'è la descrizione del lavoro di lui.
8:16
Un prompt utente è una tantum
8:17
ma è una richiesta specifica
8:18
mentre il metaprompt
8:19
sono istruzioni permanenti
8:20
integrate in ogni risposta.
8:22
Senza di esso Copilot
8:23
non sa se deve suonare come un contabile
8:25
o un copywriter.
8:26
Terrà semplice venere.
8:27
Mettiamola così
8:28
non assumeresti mai nessuno
8:29
senza fornire una descrizione del ruolo.
8:31
Il metaprompt
8:32
è esattamente questo per l'IA.
8:34
Dice a Copilot
8:34
quando rimanere formale
8:35
come formattare i risultati
8:37
quale tono usare
8:38
e cosa deve assolutamente evitare.
8:40
Questo fa la differenza
8:41
tra risposte che si adattano
8:42
al tuo flusso di lavoro
8:43
e risposte che sembrano
8:44
un vecchio clip
8:44
con opinioni personali.
8:46
Gli amministratori
8:46
spesso confondono i metaprompt
8:48
con i prompt
8:48
motivo per cui si frustrano.
8:50
Se lanci semplicemente
8:51
dammi le voci di registro
8:52
a Copilot senza contesto
8:54
inventerà il proprio stile.
8:56
Magari paragrafi lunghi
8:56
magari campi che non esistono.
8:59
Inserisci la stessa richiesta
9:00
nel metaprompt
9:00
come se è un assistente finanziario.
9:02
Fornisce sempre le voci di registro
9:03
come elenchi puntati
9:04
usando i nomi dei campi
9:05
di Business Central.
9:06
Solo un esempio.
9:07
All'improvviso
9:08
le risposte sono pulite
9:08
e strutturate di facile consultazione.
9:10
Il guardrail viene impostato
9:11
ancora prima
9:12
che la richiesta venga eseguita.
9:13
Microsoft ha introdotto
9:14
questa distinzione di proposito.
9:16
I prompt sono richieste temporanee
9:17
mentre i metaprompt
9:18
rimangono persistenti
9:19
per tutto il contesto della chat.
9:20
Gli sviluppatori
9:20
li impostano tramite
9:21
la code unit
9:22
dei messaggi chat AOAI
9:23
chiamando
9:24
Set Primary System Message.
9:27
Memorizzare il metaprompt
9:28
in uno spazio di archiviazione isolato
9:29
permette alla tua estensione
9:30
di recuperarlo
9:31
e aggiornarlo in sicurezza
9:32
invece di scrivere il testo
9:33
direttamente nel file AL.
9:35
Se hai dato un'occhiata
9:35
alla documentazione
9:36
vedrai esempi
9:37
che usano
9:37
Isolated Storage Set
9:38
e Isolated Storage Cat.
9:40
È il modello corretto
9:41
per l'eduzione.
9:42
Mantieni il tuo metaprompt
9:43
disponibile
9:43
ma protetto
9:44
dal perimetro di sicurezza
9:45
dell'estensione.
9:46
Passiamo ora ai dettagli tecnici.
9:48
Quando invii l'input
9:48
dell'utente
9:49
al servizio Azure Open AI
9:50
tramite il modulo AI
9:51
di Business Central
9:52
hai a che fare con budget
9:53
di token
9:53
impostazioni di temperatura
9:54
che ti piaccia o no.
9:56
Budget dei token
9:56
sono importanti.
9:57
Tuo metaprompt
9:58
più il prompt dell'utente
9:59
contano ai fini
9:59
del limite di token
10:00
da modello.
10:01
Quindi non inserire messaggi
10:02
di sistema lunghi
10:02
come Roma.
10:03
Sii preciso
10:03
e la temperatura
10:05
controlla la casualità.
10:06
Imposta una temperatura bassa
10:07
vicino allo zero
10:08
per scenari finanziari
10:09
in cui servono output
10:09
deterministici
10:10
e precisi nei campi.
10:11
Se stai creando
10:12
una funzionalità di marketing
10:13
vuoi bozze più creative
10:14
alza la temperatura
10:14
e lascia che improvvisi.
10:16
Non si tratta di indovinare.
10:17
È scritto
10:17
nelle guide di sviluppo.
10:19
Un'altra promemoria
10:19
sulla conformità.
10:20
A revisori
10:21
non importerà nulla
10:21
della tua creatività.
10:22
Allora interessa
10:23
che i numeri corrispondano.
10:24
Il tuo metaprompt
10:25
dovrebbe includere
10:25
regole di formatazione esplicite
10:27
strutture di risposta
10:28
e restrizioni
10:28
su commenti rilevanti.
10:30
In questo modo
10:30
gli output di Copilot
10:31
non sono solo gradevoli
10:32
per gli utenti.
10:33
Soprovvivono ai sistemi
10:34
a valle e controlli.
10:35
Considera il metaprompt
10:36
come parte documentazione
10:37
e parte controllo del rischio.
10:39
La distinzione di personalità
10:39
è dove le cose
10:40
si fanno interessate.
10:41
Il metaprompt
10:41
del copilot di marketing
10:42
potrebbe dirgli
10:43
di usare un linguaggio persuasivo
10:44
e di inventare slogan
10:45
per i prodotti.
10:46
Mentre il copilot finanziario
10:47
dice produci registrazioni
10:48
contabili strutturate
10:48
senza aggettivi.
10:50
Stessa AI di base
10:51
e risultati completamente diversi
10:52
perché definisci
10:53
la personalità in anticipo.
10:54
Questa è la differenza
10:55
tra un'automazione pratica
10:56
e output ingannevoli
10:57
che nessuno può usare davvero.
10:59
E anche se questa sezione
10:59
riguarda le buone maniere
11:00
non può ignorare
11:01
l'infrastruttura sottostante.
11:02
I metaprom funzionano
11:03
solo se la connessione
11:04
da Azure
11:04
è configurata correttamente.
11:06
Le AI non li elabora
11:07
localmente
11:07
in Business Central.
11:08
Passa tutto attraverso
11:09
il back-end
11:10
di Azure Open AI.
11:11
Se sbagli quella pipeline
11:13
non conterà quanto
11:13
bene hai scritto le regole.
11:14
Avrai comunque errori
11:15
e forse peggio
11:16
chiavi attivate
11:16
in modo errato.
11:17
In sintesi
11:18
i prompt sono richiesti.
11:19
Metaprom sono ordini permanenti.
11:20
Scrivili bene
11:21
e conservali in modo sicuro
11:22
controlla i token
11:22
e imposta la temperatura
11:23
adatta al compito.
11:25
È così che trasformi
11:26
il copilot
11:26
a un chiacchierone casuale
11:27
in un assistente specifico
11:28
di cui ti puoi fidare.
11:30
Se lavori con negligenza
11:31
passerai le notti
11:32
a correggere sciocchezze
11:33
ma nemmeno.
11:34
Il miglior prompt
11:34
ti salverà
11:35
se le credenziali
11:36
sono esposte.
11:37
Il vero pericolo
11:38
non è nel tono
11:39
o nel formato
11:40
ma in come proteggi
11:41
le chiavi
11:41
che permettono
11:41
a Copilot
11:42
di comunicare
11:42
con Azure Open AI.
11:45
Proteggere le chiavi
11:46
la sicurezza
11:46
azzur fatta bene.
11:48
Proteggere le chiavi
11:49
non è affascinante
11:50
ma è ciò che mantiene
11:51
sicuro il tuo tenant
11:52
evitando incidenti.
11:54
Quando Copilot
11:54
chiama Azure Open AI
11:55
necessita sempre
11:56
di tre elementi.
11:58
L'endpoint della risorsa
11:59
ovvero l'URL
12:00
di Azure Open AI
12:01
in nome
12:01
della distribuzione
12:02
e la chiave API.
12:04
Insieme
12:04
questi tre formano
12:05
la stretta di mano
12:05
che autorizza il tuo tenant
12:06
a dialogare con il modello.
12:08
Lasciarne anche solo
12:09
un esposto
12:09
non significa fare
12:10
IA ma simulare
12:11
una violazione.
12:12
Siamo chiari
12:13
non inserire mai
12:13
questi valori
12:14
direttamente nel codice
12:15
AL.
12:16
Se inserisci una chiave API
12:17
nel codice
12:18
o su GitHub
12:19
per comodità
12:20
inviti
12:20
gli scanner
12:21
a banchettare
12:22
nel tuo repository.
12:24
Gli sviluppatori
12:25
possono sminuire
12:25
il problema
12:26
ma i repository
12:26
vengono costantemente
12:28
scansionati
12:28
alla ricerca di segreti.
12:30
È così che i dati reali
12:30
dei clienti
12:31
finiscono su siti pubblici.
12:32
Non puoi risolvere
12:33
questo problema
12:33
con un semplice aggiornamento.
12:34
La strada sicura
12:35
è già stata tracciata
12:36
da Microsoft.
12:37
Per sviluppo e test
12:38
l'archiviazione isolata
12:39
in A è la scelta ideale.
12:41
Immaginala come
12:42
un armadietto privato
12:42
o estensione.
12:44
Le chiavi entrano lì
12:44
nessun'altra estensione
12:45
può vederle.
12:47
Mantiene tutto contenuto
12:48
leggero e semplice.
12:49
È perfetto per sandbox
12:50
e build di sviluppo
12:51
ma non illuderti
12:52
l'archiviazione isolata
12:53
non è per la produzione.
12:55
Il suo ambito locale
12:56
è utile per iterare
12:57
ma non è progettato
12:58
come cavò
12:58
quando sono in gioco
12:59
dati e utenti reali.
13:01
Quando vai in produzione
13:02
l'unica mossa responsabile
13:03
app Key Vault
13:04
o Azure Key Vault
13:05
per distribuzioni
13:05
su larga scala.
13:07
Considera una cassetta
13:08
di sicurezza in banca
13:09
invece di nascondere
13:09
i contanti nel cassetto.
13:11
Key Vault
13:11
conserva le tue chiavi API
13:13
in un contenitore protetto
13:14
con policy di logging
13:15
e rotazione adeguate.
13:17
Integra la tua estensione
13:18
e richiama ciò
13:19
che serve a runtime
13:19
e non esporre mai
13:20
la chiave nel codice.
13:22
È il modello
13:22
che gli auditori apprezzano
13:23
perché dimostra
13:24
che i segreti
13:25
non sono mai stati in chiaro.
13:27
È una governance noiosa
13:28
ma la noia
13:28
è esattamente ciò che vuoi
13:29
quando arrivano
13:30
i team di conformità.
13:32
Ecco un dettaglio
13:32
tratto direttamente
13:33
dalla documentazione
13:34
che fa la differenza.
13:35
In AL
13:35
puoi memorizzare
13:36
la chiave API
13:37
come testo segreto.
13:39
In questo modo
13:39
anche durante il debug
13:40
la chiave
13:41
non appare in chiaro
13:42
per essere catturata
13:42
da screenshot.
13:44
Il testo segreto
13:45
è esattamente
13:45
ciò che suggerisce.
13:46
Nasconde i valori sensibili
13:47
durante l'esecuzione.
13:49
Se non ricordi altro
13:49
di questa sezione
13:50
ricorda che questa opzione esiste.
13:52
Elimina uno dei vettori
13:53
di fuga più sciocchi
13:54
l'esposizione accidentale
13:55
da parte dello sviluppatore
13:56
nel debugger.
13:59
Ora definiamo
13:59
cosa fare e cosa non fare
14:00
parlando come veri amministratori.
14:02
Non inserire chiavi API
14:04
nel codice AL
14:05
né incollarle nei repository.
14:06
È un invito a nozze
14:07
per il furto di credenziali.
14:09
Usa l'archiviazione
14:09
isolata per lo sviluppo
14:10
e i test
14:11
così manterrà il team produttivo
14:12
senza inviare segreti in chiaro.
14:15
Non trascinare
14:15
quel modello di sviluppo
14:16
in produttivo.
14:17
Non è un cavo
14:17
è uno schedario.
14:19
Collega la tua build
14:19
di produzione al key vault
14:20
è l'unico posto
14:21
a cui quelle chiavi
14:22
appartengono a te.
14:23
Un altro punto di buon senso
14:24
le autorizzazioni utenti
14:25
all'interno di Business Central
14:26
non bloccano magicamente
14:27
le chiavi API.
14:29
Copilot
14:29
otterrà edita il controllo
14:30
di accesso ai dati aziendali
14:31
certo ma le chiavi servono
14:32
ad autenticare l'intero servizio.
14:33
Se una chiave viene trafugata
14:35
estranei possono impersonare
14:36
l'integrazione.
14:37
Quindi smettila di fingere
14:38
che la definizione
14:38
di aliame di autorizzazione
14:39
di sa non lo fa.
14:40
E se vuoi combalidare
14:41
la tua configurazione
14:42
la procedura ufficiale
14:43
è la sequenza di autorizzazione
14:44
impostata nell'unità di codice
14:45
ESL OpenAI.
14:47
È lì che inserisci
14:47
l'URL della risorsa
14:48
e il deployment
14:49
della chiave API
14:49
per verificare che tutto
14:50
sia allineato.
14:51
Se sbagli
14:52
il copilot
14:52
non verrà nemmeno caricato.
14:54
Se lo fai a metà
14:54
otterrai errori silenziosi
14:55
che gli utenti
14:56
troveranno prima di te.
14:58
La soluzione è semplice.
14:59
Segui la catena in ordine
14:59
testa l'appuratamente
15:00
sviluppo
15:01
poi passa alla preproduzione
15:02
e infine alla produzione.
15:03
Tre ambienti
15:04
tre set di chiavi
15:05
una pipeline
15:05
che funziona davvero
15:06
sotto carico.
15:07
Ecco quindi
15:08
la tua lista di controllo
15:08
per evitare
15:09
archiviazione isolata
15:10
in sviluppo
15:11
chi volti in produzione
15:12
racchiudi la chiave
15:12
AI in testo segreto
15:14
non inserire mai valori
15:15
nel codice
15:15
e avvia sempre
15:16
la catena di autorizzazione
15:17
completa
15:18
prima di considerare
15:19
il lavoro finito.
15:21
Questo modello
15:22
mantiene la tua
15:22
integrazione di copilot
15:23
attiva, sicura, conforme
15:24
senza emergenze notturne.
15:27
Gestito l'aspetto
15:27
della sicurezza
15:28
la sfida successiva
15:29
riguarda meno
15:29
dove nascondere le chiavi
15:30
e più come far connettere
15:31
tutte le parti
15:32
senza costanti messaggi
15:33
di errore.
15:35
Perché avere una funzionalità
15:36
o un metaprompto
15:37
e una chiave sicura
15:38
non serve a molto
15:38
se restano isolati
15:39
e si rifiutano di collaborare.
15:41
È qui che entra in gioco
15:41
il cablaggio del flusso di lavoro.
15:43
Dal progetto alla realtà
15:44
collegando il flusso di lavoro
15:45
parliamo di ciò
15:46
che trasforma componenti
15:48
sparsi in un vero flusso
15:48
di lavoro copilot funzionante.
15:51
Ha registrato
15:51
una funzionalità
15:52
definito l'ambito
15:53
ottenuto le chiavi
15:54
e scritto il metaprompto
15:55
ma se non li metti in ordine
15:57
otterrai
15:58
solo un pulsante luccicante
15:59
che va in errore
16:00
o non fa nulla
16:01
finché gli utenti
16:02
non aprono ticket.
16:04
Ecco la sequenza ridotta
16:06
a 5 semplici passaggi.
16:07
Primo passaggio
16:08
funzionalità
16:08
Secondo passaggio
16:10
disponibilità
16:10
Terzo passaggio
16:11
autorizzazione
16:12
Quarto passaggio
16:13
metaprompto
16:14
Quinto passaggio
16:14
pilotaggio
16:15
Ricorda questi 5
16:16
e avrai sempre
16:17
lo schema di collegamento
16:18
in me
16:18
La funzionalità
16:19
conferisce l'abilità
16:20
la disponibilità
16:20
definisce il pubblico
16:21
l'autorizzazione
16:22
attiva il cervello
16:22
il metaprompto
16:23
detto alle buone maniere
16:24
il pilotaggio
16:24
prova che funziona davvero
16:25
questo è l'intero ciclo
16:26
primo passaggio
16:27
funzionalità
16:28
in AL significa
16:29
estendere l'enum
16:30
della funzionalità
16:31
copilot
16:31
con un'estensione
16:32
enum
16:32
puoi registrarla
16:33
in una codiunita
16:33
di installazione
16:34
o aggiornamento
16:35
chiamandola
16:35
funzionalità
16:36
copilot
16:36
registra la funzionalità
16:38
è l'annuncio ufficiale
16:39
che dice ecco
16:39
una nuova abilità
16:40
dell'assistente
16:41
dà di uno spazio
16:42
nel sistema
16:42
senza questo
16:43
Business Central
16:44
non saprà mai
16:45
che la tua funzionalità
16:46
dovrebbe esistere
16:47
secondo passaggio
16:48
disponibile
16:49
una volta definita
16:50
l'abilità
16:50
ne stabilisci
16:51
l'ambito di visibilità
16:52
questo si controlla
16:54
tramite la pagina
16:54
di amministrazione
16:55
delle funzioni
16:55
datico payload
16:56
le cd2
16:57
è contrassegnata
16:57
come anteprima
16:58
solo interno
16:59
e generalmente disponibile
17:00
gli sviluppatori
17:00
lo vedono come metadati
17:01
ma per gli amministratori
17:02
e l'interruttore
17:03
per il rilascio
17:04
usalo
17:04
se salti questo passaggio
17:06
rischi di esporre
17:07
funzionalità incomplete
17:08
a tutti gli utenti
17:08
prima che siano stabili
17:09
terzo passaggio
17:11
autorizzazione
17:11
ora colleghi il back-end
17:13
di Azure OpenAI
17:14
tramite la code unit
17:15
di Azure OpenAI
17:16
ti serve la classica triade
17:18
endpoint della risorsa
17:19
URL di Azure OpenAI
17:21
nome della distribuzione
17:22
e chiave API
17:22
chiama Azure OpenAI
17:25
imposta l'autorizzazione
17:26
con quei valori
17:27
se la funzionalità
17:29
era l'annuncio di lavoro
17:30
e la disponibilità
17:31
al contratto
17:31
l'autorizzazione
17:32
è il badge
17:32
per far entrare
17:32
l'assistente nell'edificio
17:34
senza di essere
17:35
la funzione
17:35
resta bloccata
17:36
davanti alla portaventura
17:37
quarto passaggio
17:37
metaprom
17:38
qui inserisci
17:39
le istruzioni permanenti
17:40
che definiscono
17:40
tono, struttura
17:41
e formattazione
17:42
usa i messaggi
17:43
di chat AI
17:44
imposta il messaggio
17:46
di sistema primario
17:46
per recuperare il metaprom
17:48
che hai archiviato
17:48
in modo sicuro
17:49
in uno storage isolato
17:50
o in produzione
17:50
referenziato da Key Vault
17:51
è qui che dici
17:53
sei un assistente preventivo
17:54
oppure sei un assistente finanziario
17:55
e definisci
17:56
l'aspetto dell'output
17:57
senza questo
17:59
l'assistente alza le spalle
18:00
e inventa tutto
18:00
quinto passaggio
18:01
pilotaggio
18:02
distribuiscilo prima
18:03
a un piccolo gruppo
18:03
fornisci loro la funzionalità
18:05
raccogli i feedback
18:05
e monitora la telemetria
18:06
il modulo AI
18:07
registra l'utilizzo
18:08
così puoi vedere
18:09
se produce risultati puliti
18:10
o se genera dati inutili
18:11
e prima di espanderti
18:12
ti serve un piano di rollback
18:13
è buona notizia
18:14
che la pagina
18:15
delle funzionalità
18:15
di copilot
18:16
degli agenti
18:16
funge anche
18:17
dei dispositivi di metodo
18:18
gli amministratori
18:18
possono disattivare
18:19
istantaneamente
18:20
le singole funzionalità
18:21
se qualcosa inizia a non funzionare
18:22
quella stessa pagina
18:23
mostra anche
18:24
l'interruttore
18:24
per il movimento
18:25
consentito dei dati
18:26
tra le regiografiche
18:26
se la tua configurazione
18:27
è a zero attraverso più regione
18:28
se vedi quell'opzione
18:29
presta attenzione
18:30
qualcuno della conformità
18:31
lo farà
18:32
vediamo di mettere a punto
18:33
questa sequenza
18:33
con esempio
18:33
un team ha creato
18:35
un copilot
18:35
per i suggerimenti
18:36
sugli ordini di venti
18:37
hanno iniziato
18:38
con un'estensione
18:38
enum
18:39
per la funzionalità copilot
18:40
e l'hanno collegata
18:40
a una code unit installata
18:41
l'hanno contrassegnata
18:42
come anteprima
18:43
nella pagina
18:43
delle funzionalità
18:44
di copilot
18:45
e degli agenti
18:45
in modo che fosse visibile
18:46
solo gli utenti di test
18:47
poi hanno chiamato
18:48
Azure OpenAI
18:48
hanno impostato
18:49
l'autorizzazione
18:50
con endpoint
18:50
distribuzione chiave
18:51
affinché il modello
18:52
potesse effettivamente rispondere
18:53
successivamente
18:54
hanno scritto
18:55
un metaprompto
18:56
in un archivio isolato
18:56
e l'hanno impostato
18:57
con i messaggi di chat
18:58
o AI
18:58
imposta il messaggio
19:00
di sistema principale
19:01
ti ho un assistente preventivo
19:02
suggerisci pacchetti
19:03
e formatali
19:04
come righe di articolo
19:04
nessuna chiacchiera superflua
19:06
nella fase pilota
19:07
da piccoli gruppi
19:07
hanno effettuato test
19:08
finché i risultati
19:08
non sono stati preveniti
19:09
solo allora
19:10
hanno contrassegnato
19:11
la disponibilità come GA
19:12
rendendolo attivo
19:13
per tutti gli utenti
19:13
delle vendite
19:14
il risultato
19:15
un copilot
19:15
che consigliava pacchetti
19:16
invece di scrivere in utilità
19:17
il livello di governance
19:19
qui non è opzionale
19:20
se qualcosa va storto
19:21
gli amministratori
19:22
possono disattivare
19:23
l'interruttore
19:23
prima che l'identichiamo
19:24
quella mentalità
19:25
da interruttore di sicurezza
19:26
è ciò che mantiene
19:26
i copilot personalizzati
19:27
produttivi
19:28
anziché di romperli
19:29
applicala come faresti
19:30
con qualsiasi estensione
19:31
rilasci graduali
19:32
ambito limitato
19:33
test misurabili
19:34
line non riceve
19:35
un lascia passare
19:35
esegui ogni parte
19:36
in isolamento
19:37
quando effetti i test
19:38
non colleghi la intera catena
19:39
tranne che funzioni
19:39
convalida la registrazione
19:41
della funzionalità
19:42
verifica che la disponibilità
19:43
appaia correttamente
19:44
conferma l'autorizzazione
19:45
con set authorization
19:46
quindi conferma
19:47
che il metaprompt
19:48
sia efficace nelle risposte
19:49
solo quando ogni pezzo funziona
19:50
lascia che gli utenti finali
19:51
lo utilizzino
19:52
questo è il ponte
19:53
dal progetto alla realtà
19:54
in poche parole
19:55
la funzionalità
19:56
definisce le abilità
19:56
la disponibilità
19:57
delimita il pubblico
19:58
l'autorizzazione
19:58
apre la porta
19:59
il metaprompt
20:00
stabilisce le regole
20:00
e il pilota dimostra
20:01
che il sistema
20:02
non ti metterà in imbarazzo
20:04
se ottieni questi risultati
20:05
sarai in vantaggio
20:05
rispetto ai rilasci ufficiali
20:06
delle funzionalità
20:07
e questo ci riporta
20:08
al punto principale
20:08
questi passaggi
20:09
sono ciò che ti permette
20:10
di plasmare Copilot
20:11
attorno alla tua attività
20:11
invece di seguire
20:12
passivamente
20:13
qualsiasi demo
20:14
preconfezionata
20:14
mostrata da Microsoft
20:15
sul palco
20:16
quindi ecco il riepilogo
20:18
tre cose da tenere a mente
20:19
primo
20:20
estendi Copilot
20:21
tramite l'ID sistema
20:22
registrando le funzionalità
20:23
due
20:25
proteggi la connessione azzur
20:26
usa l'archiviazione isolata
20:27
durante i test
20:28
ma sposta quelle chiavi
20:29
in key vault
20:29
per la produzione
20:30
tre pilota e governa
20:31
le funzionalità
20:32
dalla pagina
20:32
delle funzionalità
20:33
di Copilot e agenti
20:34
così gli amministratori
20:35
hanno sempre il controllo totale
20:36
un rapido promemoria
20:37
per chi si occupa di governance
20:38
Copilot eredita
20:40
le autorizzazioni utente
20:41
quindi non legge mai
20:41
ciò a cui l'utente
20:42
non può accedere
20:43
e Microsoft
20:44
non addestra modelli
20:44
sui dati del tuo tenant
20:45
a meno che tu
20:46
non lo consente esplicitamente
20:47
prossimo passo
20:49
prova una funzionalità
20:49
nel tuo ambiente sandbox
20:50
questa settimana
20:51
e verifica che funzioni
20:52
correttamente
20:53
seguendo la lista di controllo
20:56
M365Show
20:56
per aggiornamenti
20:57
sulla guida di sopravvivenza
20:57
e segui la pagina
20:58
LinkedIn di M365Show
21:00
per non perdere i live streaming
21:00
con gli MVP
21:01
che hanno già testato
21:01
e risolto questi problemi