Eseguire la migrazione di carichi di lavoro lambda AWS a Funzioni di Azure

La migrazione di un carico di lavoro serverless che utilizza Amazon Web Services (AWS) Lambda verso le Funzioni di Azure richiede una pianificazione ed un'implementazione attente. Questo articolo fornisce indicazioni essenziali che consentono di:

• Eseguire un processo di individuazione del carico di lavoro esistente.
• Impara come svolgere attività essenziali di migrazione, come la pianificazione della pre-migrazione e la valutazione del carico di lavoro.
• Valutare e ottimizzare un carico di lavoro migrato.

Ambito

Questo articolo descrive la migrazione di un'istanza lambda di AWS a Funzioni di Azure.

Questo articolo non si rivolge a:

• Migrazione alla propria soluzione di hosting dei contenitori, ad esempio tramite App Contenitore di Azure.
• Hosting di contenitori lambda AWS in Azure.
• Approcci fondamentali all'adozione di Azure da parte dell'organizzazione, ad esempio zone di destinazione di Azure o altri argomenti trattati nella metodologia di migrazione di Cloud Adoption Framework.

Confrontare la funzionalità

Questo articolo associa le funzionalità lambda di AWS agli equivalenti di Funzioni di Azure per garantire la compatibilità.

Prospettiva del carico di lavoro

Questo articolo è incentrato su come eseguire la migrazione di un carico di lavoro lambda AWS a Funzioni di Azure e sulle dipendenze comuni per i carichi di lavoro serverless. Questo processo potrebbe comportare diversi servizi perché i carichi di lavoro comprendono molte risorse e processi per gestire tali risorse. Per avere una strategia completa, è necessario combinare le raccomandazioni presentate in questo articolo con un piano più ampio che include gli altri componenti e processi nel carico di lavoro.

Eseguire un processo di individuazione del carico di lavoro esistente

Il primo passaggio consiste nell'eseguire un processo di individuazione dettagliato per valutare il carico di lavoro AWS Lambda esistente. L'obiettivo è comprendere le funzionalità e i servizi aws su cui si basa il carico di lavoro. Compilare un inventario completo delle funzioni lambda di AWS usando strumenti aws come SDK specifici del servizio, API, CloudTrail e interfaccia della riga di comando di AWS per valutare il carico di lavoro in AWS. È necessario comprendere gli aspetti chiave seguenti dell'inventario LAMBDA di AWS:

• Casi d'uso
• Configurazioni
• Configurazioni di sicurezza e rete
• Strumenti, monitoraggio, registrazione e meccanismi di osservabilità
• Dipendenze
• Obiettivi di affidabilità e stato di affidabilità corrente
• Costo di proprietà
• Obiettivi di prestazioni e prestazioni correnti

Eseguire la pianificazione della premigrazione

Prima di iniziare la migrazione del carico di lavoro, è necessario eseguire il mapping delle funzionalità lambda di AWS a Funzioni di Azure per garantire la compatibilità e sviluppare un piano di migrazione. È quindi possibile selezionare i carichi di lavoro chiave per un modello di verifica.

È anche necessario eseguire il mapping dei servizi AWS da cui Lambda dipende dalle dipendenze equivalenti in Azure.

Mappare le funzionalità Lambda di AWS su Funzioni di Azure

Le tabelle seguenti confrontano concetti, risorse e proprietà lambda di AWS con gli equivalenti corrispondenti in Funzioni di Azure, in particolare il piano di hosting Flex Consumption.

• Lingue supportate
• Modello di programmazione
• Trigger e associazioni di eventi
• Autorizzazioni
• URL funzione
• Networking
• Osservabilità e monitoraggio
• Ridimensionamento e concorrenza
• Protezione di avvio a freddo
• Prezzi
• Archiviazione del codice sorgente
• Sviluppo in locale
• Distribuzione
• Limiti di timeout e memoria
• Gestione dei segreti
• Gestione dello stato
• Orchestrazione con stato
• Altre differenze e considerazioni

Lingue disponibili

Modello di programmazione

Trigger di eventi e associazioni

Autorizzazioni

URL della funzione

Rete

Osservabilità e monitoraggio

Ridimensionamento e concorrenza

Protezione di avvio a freddo

Tariffazione

Archiviazione del codice sorgente

Sviluppo locale

Distribuzione

Timeout e limiti di memoria

Gestione dei segreti

Gestione dello stato

Orchestrazione con stato

Altre differenze e considerazioni

Creare un piano di migrazione

1. Selezionare i carichi di lavoro chiave per un modello di verifica.

   Per iniziare, selezionare uno o due carichi di lavoro non critici di medie dimensioni dall'inventario totale. Questi carichi di lavoro fungono da base per la migrazione di modelli di verifica. È possibile testare il processo e identificare potenziali sfide senza rischiare gravi interruzioni delle operazioni.

2. Testare in modo iterativo e raccogliere feedback.

   Usare il modello di verifica per raccogliere feedback, identificare le lacune e ottimizzare il processo prima di passare a carichi di lavoro più grandi. Questo approccio iterativo garantisce che, nel momento in cui si passa alla migrazione su larga scala, si affrontino potenziali sfide e si affina il processo.

Creare le risorse di migrazione

Questo passaggio è una fase di sviluppo transitorio. Durante questa fase si compila il codice sorgente, i modelli di infrastruttura come codice (IaC) e le pipeline di distribuzione per rappresentare il carico di lavoro in Azure. Prima di poter eseguire la migrazione, è necessario adattare il codice della funzione per la compatibilità e le procedure consigliate.

• Adattare il codice della funzione, i file di configurazione e l'infrastruttura come file di codice
• Modificare le impostazioni di configurazione
• Generare file IaC
• Usare gli strumenti per il refactoring

Adattare il codice della funzione, i file di configurazione e l'infrastruttura come file di codice

Per aggiornare il codice in base ai requisiti del runtime delle Funzioni di Azure:

• Modificare il codice in modo da rispettare il modello di programmazione di Funzioni di Azure. Ad esempio, adattare le firme di funzione in modo che corrispondano al formato richiesto da Funzioni di Azure. Per altre informazioni sulla definizione della funzione e sul contesto di esecuzione, vedere Guide per sviluppatori di Funzioni di Azure.

• Usare il bundle delle estensioni di Funzioni di Azure per gestire varie associazioni e trigger simili ai servizi AWS. Per le applicazioni .NET, è consigliabile usare i pacchetti NuGet appropriati anziché il bundle delle estensioni.

• Usare il bundle di estensioni per l'integrazione con altri servizi di Azure, ad esempio Archiviazione di Azure, bus di servizio di Azure e Azure Cosmos DB senza dover configurare manualmente ogni associazione tramite SDK. Per altre informazioni, vedere Connettere le funzioni ai servizi di Azure usando associazioni e modelli di espressione di associazione di Funzioni di Azure.

I frammenti di codice seguenti sono esempi di codice SDK comune. Il codice Lambda di AWS corrisponde ai trigger, alle associazioni o ai frammenti di codice SDK corrispondenti in Azure Functions.

Lettura da Amazon S3 rispetto ad Archiviazione BLOB di Azure

const AWS = require('aws-sdk');
const s3 = new AWS.S3();

exports.handler = async (event) => {
const params = {
Bucket: 'my-bucket',
Key: 'my-object.txt',
};
const data = await
s3.getObject(params).promise();
console.log('File content:',
data.Body.toString());
};       

import { app } from '@azure/functions';

app.storageblob('blobTrigger', { 
path: 'my-container/{blobName}',
connection: 'AzureWebJobsStorage',
}, async (context, myBlob) => { 
context.log(`Blob content:
${myBlob.toString()}`);
});

Scrittura in Amazon Simple Queue Service (SQS) rispetto ad archiviazione code di Azure

const AWS = require('aws-sdk');
const sqs = new AWS.SQS(); 

exports.handler = async (event) => {
const params = {
QueueUrl:
'https://sqs.amazonaws.com/123456789012/MyQueue',
MessageBody: 'Hello, world!',
};
await
sqs.sendMessage(params).promise();
};

import { app } from '@azure/functions';

app.queue('queueTrigger', { 
queueName: 'myqueue-items',
connection: 'AzureWebJobsStorage',
}, async (context, queueMessage) => {
context.log(`Queue message: 
${queueMessage}`);
}); 

Scrittura in DynamoDB rispetto ad Azure Cosmos DB

const AWS = require('aws-sdk'); 
const dynamoDb = new AWS.DynamoDB.DocumentClient();   

exports.handler = async (event) => { 
const params = { 
TableName: 'my-table', 
Key: { id: '123' }, 
}; 
const data = await dynamoDb.get(params).promise(); 
console.log('DynamoDB record:', data.Item); 
}; 

import { app } from '@azure/functions';  

app.cosmosDB('cosmosTrigger', { 
connectionStringSetting: 'CosmosDBConnection', 
databaseName: 'my-database', 
containerName: 'my-container', 
leaseContainerName: 'leases', 
}, async (context, documents) => { 
documents.forEach(doc => { 
context.log(`Cosmos DB document: ${JSON.stringify(doc)}`); 
}); 
}); 

Eventi di Amazon CloudWatch rispetto a un trigger timer di Azure

exports.handler = async (event) => {
console.log('Scheduled event:', event); 
}; 

import { app } from '@azure/functions'; 

app.timer('timerTrigger', { schedule: '0 */5 * * * *', // Runs every 5 minutes }, async (context, myTimer) => { if (myTimer.isPastDue) { context.log('Timer is running late!'); } context.log(Timer function executed at: ${new Date().toISOString()}); });

Amazon Simple Notification Service (SNS) rispetto a un trigger di Griglia di eventi di Azure

const AWS = require('aws-sdk'); 
const sns = new AWS.SNS();   

exports.handler = async (event) => { 
const params = { 
Message: 'Hello, Event Grid!', 
TopicArn: 'arn:aws:sns:us-east-1:123456789012:MyTopic', 
}; 
await sns.publish(params).promise(); 
}; 

import { app } from '@azure/functions'; 

app.eventGrid('eventGridTrigger', {}, 
async (context, eventGridEvent) => { 

context.log(`Event Grid event: 
${JSON.stringify(eventGridEvent)}`); 

}); 

Amazon Kinesis rispetto a un trigger di Azure Event Hubs

const AWS = require('aws-sdk'); 
const kinesis = new AWS.Kinesis();   

exports.handler = async (event) => { 
const records = 
event.Records.map(record => 
Buffer.from(record.kinesis.data, 
'base64').toString()); 
console.log('Kinesis records:', records); 
}; 

import { app } from '@azure/functions'; 
app.eventHub('eventHubTrigger', {  
connection: 'EventHubConnection',  
eventHubName: 'my-event-hub',  
}, async (context, eventHubMessages) => 
{  
eventHubMessages.forEach(message => 
{  
context.log(`Event Hub message: 
${message}`);  
});  
});

Vedere i repository GitHub seguenti per confrontare il codice lambda di AWS e il codice di Funzioni di Azure:

• Codice lambda AWS
• Codice di Funzioni di Azure
• Repository di esempi di Azure, che include esempi iniziali, IaC e completi per Funzioni di Azure

Modificare le impostazioni di configurazione

Assicurarsi che le impostazioni di timeout e memoria della funzione siano compatibili con Funzioni di Azure. Per altre informazioni sulle impostazioni configurabili, vedere host.json riferimento per Funzioni di Azure.

Seguire le procedure consigliate per le autorizzazioni, l'accesso, la rete e le configurazioni di distribuzione.

Configura autorizzazioni

Seguire le procedure consigliate quando si configurano le autorizzazioni per le app per le funzioni. Per altre informazioni, vedere Configurare l'app per le funzioni e l'account di archiviazione con identità gestita.

main.bicep

// User-assigned managed identity that the function app uses to reach Storage and Service Bus
module processorUserAssignedIdentity './core/identity/userAssignedIdentity.bicep' = {
  name: 'processorUserAssignedIdentity'
  scope: rg
  params: {
    location: location
    tags: tags
    identityName: !empty(processorUserAssignedIdentityName) ? processorUserAssignedIdentityName : '${abbrs.managedIdentityUserAssignedIdentities}processor-${resourceToken}'
  }
}

Per altre informazioni, vedere rbac.bicep.

Configurare l'accesso alla rete

Le Funzioni di Azure supportano l'integrazione della rete virtuale, che consente alla tua app di funzioni di accedere alle risorse nella tua rete virtuale. Dopo l'integrazione, l'app instrada il traffico in uscita attraverso la rete virtuale. L'app può quindi accedere a endpoint o risorse privati usando regole che consentono solo il traffico da subnet specifiche. Se la destinazione è un indirizzo IP all'esterno della rete virtuale, l'indirizzo IP di origine è uno degli indirizzi elencati nelle proprietà dell'app, a meno che non si configuri un gateway NAT.

Quando si abilita l'integrazione della rete virtuale per le app per le funzioni, seguire le procedure consigliate in TSG per l'integrazione della rete virtuale per app Web e app per le funzioni.

main.bicep

// Virtual network and private endpoint
module serviceVirtualNetwork 'app/vnet.bicep' = {
  name: 'serviceVirtualNetwork'
  scope: rg
  params: {
    location: location
    tags: tags
    vNetName: !empty(vNetName) ? vNetName : '${abbrs.networkVirtualNetworks}${resourceToken}'
  }
}  

module servicePrivateEndpoint 'app/storage-PrivateEndpoint.bicep' = {
  name: 'servicePrivateEndpoint'
  scope: rg
  params: {
    location: location
    tags: tags
    virtualNetworkName: !empty(vNetName) ? vNetName : '${abbrs.networkVirtualNetworks}${resourceToken}'
    subnetName: serviceVirtualNetwork.outputs.peSubnetName
    resourceName: storage.outputs.name
  }
}

Per altre informazioni, vedere VNet.bicep e storage-PrivateEndpoint.bicep.

Configurare le impostazioni di distribuzione

Le distribuzioni seguono un unico percorso. Dopo aver compilato il codice del progetto e comprimerlo in un pacchetto dell'applicazione, distribuirlo in un contenitore di archiviazione BLOB. All'avvio, l'app ottiene il pacchetto ed esegue il codice della funzione da esso. Per impostazione predefinita, lo stesso account di archiviazione che archivia i metadati host interni, ad esempio AzureWebJobsStorage, funge anche da contenitore di distribuzione. Tuttavia, è possibile usare un account di archiviazione alternativo o scegliere il metodo di autenticazione preferito configurando le impostazioni di distribuzione dell'app. Per altre informazioni, vedere Dettagli della tecnologia didistribuzione e Configurare le impostazioni di distribuzione.

Generare file IaC

• Usare strumenti come Bicep, modelli di Azure Resource Manager o Terraform per creare file IaC per distribuire le risorse di Azure.

• Definire risorse come Funzioni di Azure, account di archiviazione e componenti di rete nei file IaC.

• Usare questo repository di esempi IaC per esempi che usano consigli e procedure consigliate di Funzioni di Azure.

Usare gli strumenti per il refactoring

Usare strumenti come GitHub Copilot in VS Code per facilitare il refactoring del codice, il refactoring manuale per modifiche specifiche o altri strumenti di migrazione.

Gli articoli seguenti forniscono esempi specifici e passaggi dettagliati per facilitare il processo di migrazione:

• Azure per professionisti di AWS
• Sviluppare Funzioni di Azure in locale usando Core Tools

Sviluppare un processo dettagliato per la migrazione del giorno 0

Sviluppa strategie di failover e failback per la migrazione e testale accuratamente in un ambiente di preproduzione. È consigliabile eseguire test end-to-end prima di passare infine da AWS Lambda a Funzioni di Azure.

• Convalidare le funzionalità

  • Codice e test di Funzioni di Azure in locale.

  • Testare attentamente ogni funzione per assicurarsi che funzioni come previsto. Questi test devono includere input/output, trigger di eventi e verifica delle associazioni.

  • Usare strumenti come curl o estensioni client REST in VS Code per inviare richieste HTTP per le funzioni attivate da HTTP.

  • Per altri trigger, ad esempio timer o code, assicurarsi che i trigger vengano attivati correttamente e che le funzioni vengano eseguite come previsto.

• Convalidare le prestazioni

  • Eseguire test delle prestazioni per confrontare la nuova distribuzione di Funzioni di Azure con la precedente distribuzione lambda di AWS.

  • Monitorare le metriche, ad esempio il tempo di risposta, il tempo di esecuzione e l'utilizzo delle risorse.

  • Usare Application Insights per il monitoraggio, l'analisi dei log e la risoluzione dei problemi durante la fase di test.

• Risolvere i problemi usando la funzionalità diagnostica e risoluzione dei problemi

  Usare la funzionalità di diagnosi e risoluzione dei problemi nel portale di Azure per risolvere i problemi relativi all'app per le funzioni. Questo strumento fornisce un set di funzionalità di diagnostica che consentono di identificare e risolvere rapidamente problemi comuni, ad esempio arresti anomali dell'applicazione, riduzione delle prestazioni e problemi di configurazione. Seguire la procedura guidata per la risoluzione dei problemi e i suggerimenti forniti dallo strumento per risolvere i problemi identificati.

Valutare lo stato finale del carico di lavoro migrato

Prima di rimuovere le risorse in AWS, è necessario assicurarsi che la piattaforma soddisfi le aspettative correnti del carico di lavoro e che nulla blocchi la manutenzione del carico di lavoro o un ulteriore sviluppo.

Distribuire e testare funzioni per convalidare le prestazioni e la correttezza.

Distribuzione su Azure

Distribuire i carichi di lavoro usando la funzionalità di pubblicazione di VS Code . È anche possibile distribuire carichi di lavoro dalla riga di comando usando Azure Functions Core Tools o l'interfaccia della riga di comando di Azure. Azure DevOps e GitHub Actions usano anche One Deploy.

• Azure Functions Core Tools: distribuire la app per le funzioni usando Azure Functions Core Tools con il comando func azure functionapp publish <FunctionAppName>.

• Pipeline di integrazione continua e distribuzione continua (CI/CD): configurare una pipeline CI/CD usando servizi come GitHub Actions, Azure DevOps o un altro strumento CI/CD.

  Per altre informazioni, vedere Recapito continuo con GitHub Actions o Recapito continuo con Azure Pipelines.

Esplorare gli scenari di migrazione di esempio

Usare il repository MigrationGetStarted come modello per iniziare il proof of concept. Questo repository include un progetto di Funzioni di Azure pronto per la distribuzione che include i file di codice sorgente e dell'infrastruttura per iniziare.

Se si preferisce usare Terraform, usare MigrationGetStarted-Terraform .

Ottimizzare e monitorare le prestazioni dell'applicazione in Azure

Dopo aver eseguito la migrazione del carico di lavoro, è consigliabile esplorare altre funzionalità in Azure. Queste funzionalità possono aiutare a soddisfare i requisiti futuri del carico di lavoro e a colmare le lacune.

Usare Application Insights per il monitoraggio e la risoluzione dei problemi

Abilitare Application Insights per l'app per le funzioni per raccogliere dati di telemetria dettagliati per il monitoraggio e la risoluzione dei problemi. È possibile abilitare Application Insights tramite il portale di Azure o nel file di configurazione host.json dell'app per le funzioni. Dopo aver abilitato Application Insights, è possibile:

• Raccogliere i dati di telemetria. Application Insights fornisce vari dati di telemetria, ad esempio i log delle richieste, le metriche delle prestazioni, le eccezioni e le dipendenze.

• Analizzare log e metriche. Accedere al dashboard di Application Insights dal portale di Azure per visualizzare e analizzare log, metriche e altri dati di telemetria. Usare gli strumenti predefiniti per creare query personalizzate e visualizzare i dati per ottenere informazioni dettagliate sulle prestazioni e sul comportamento dell'app per le funzioni.

• Configurare gli avvisi. Configurare gli avvisi in Application Insights per notificare problemi critici, riduzione delle prestazioni o eventi specifici. Questi avvisi consentono di monitorare e rispondere rapidamente ai problemi in modo proattivo.

Ottimizzare i costi e le prestazioni

• Ridimensionamento e ottimizzazione delle prestazioni:

  • Usare le funzionalità di scalabilità automatica per gestire in modo efficiente carichi di lavoro diversi.

  • Ottimizzare il codice della funzione per migliorare le prestazioni riducendo il tempo di esecuzione, ottimizzando le dipendenze e usando procedure di codifica efficienti.

  • Implementare strategie di memorizzazione nella cache per ridurre l'elaborazione e la latenza ripetute per i dati a cui si accede di frequente.

• Gestione costi:

  • Usare gli strumenti di Gestione costi Microsoft per monitorare e analizzare i costi di Funzioni di Azure.

  • Configurare avvisi relativi al budget e ai costi per gestire e prevedere le spese in modo efficace.