Migrera AWS Lambda-arbetsbelastningar till Azure Functions

Att migrera en serverlös arbetsbelastning som använder Amazon Web Services (AWS) Lambda till Azure Functions kräver noggrann planering och implementering. Den här artikeln innehåller viktig vägledning som hjälper dig:

• Utför en upptäcktsprocess på din befintliga arbetslast.
• Lär dig hur du utför viktiga migreringsaktiviteter som planering före migrering och utvärdering av arbetsbelastningar.
• Utvärdera och optimera en migrerad arbetsbelastning.

Omfång

I den här artikeln beskrivs migreringen av en AWS Lambda-instans till Azure Functions.

Den här artikeln tar inte upp:

• Migrering till din egen containervärdlösning, till exempel via Azure Container Apps.
• Värd för AWS Lambda-containrar i Azure.
• Grundläggande azure-implementeringsmetoder för din organisation, till exempel Azure-landningszoner eller andra ämnen som tas upp i migreringsmetodiken Cloud Adoption Framework.

Jämför funktioner

Den här artikeln mappar AWS Lambda-funktioner till Azure Functions-motsvarigheter för att säkerställa kompatibilitet.

Arbetsbelastningsperspektiv

Den här artikeln fokuserar på hur du migrerar en AWS Lambda-arbetsbelastning till Azure Functions och de vanliga beroendena för serverlösa arbetsbelastningar. Den här processen kan omfatta flera tjänster eftersom arbetsbelastningar omfattar många resurser och processer för att hantera dessa resurser. Om du vill ha en omfattande strategi måste du kombinera rekommendationerna i den här artikeln med en större plan som innehåller de andra komponenterna och processerna i din arbetsbelastning.

Utför en identifieringsprocess för din befintliga arbetsbelastning

Det första steget är att genomföra en detaljerad identifieringsprocess för att utvärdera din befintliga AWS Lambda-arbetsbelastning. Målet är att förstå vilka AWS-funktioner och tjänster som din arbetsbelastning förlitar sig på. Kompilera en omfattande inventering av dina AWS Lambda-funktioner med hjälp av AWS-verktyg som tjänstspecifika SDK:er, API:er, CloudTrail och AWS CLI för att utvärdera arbetsbelastningen på AWS. Du bör förstå följande viktiga aspekter av din AWS Lambda-inventering:

• Användningsfall
• -konfigurationer
• Säkerhets- och nätverkskonfigurationer
• Verktygs-, övervaknings-, loggnings- och observerbarhetsmekanismer
• Beroenden
• Tillförlitlighetsmål och aktuell tillförlitlighetsstatus
• Ägandekostnad
• Prestandamål och aktuell prestanda

Utför planering inför förflyttning

Innan du börjar migrera din arbetsbelastning måste du mappa AWS Lambda-funktioner till Azure Functions för att säkerställa kompatibilitet och utveckla en migreringsplan. Sedan kan du välja viktiga arbetsuppgifter för en prototyp.

Du måste också mappa de AWS-tjänster som Lambda är beroende av till motsvarande beroenden i Azure.

Mappa AWS Lambda-funktioner till Azure Functions

Tabellerna nedan jämför AWS Lambda-begrepp, resurser och egenskaper med sina motsvarigheter i Azure Functions, speciellt Flex Consumption-värdplanen.

• Språk som stöds
• Programmeringsmodell
• Händelseutlösare och bindningar
• behörigheter
• Funktions-URL
• Nätverk
• Observerbarhet och övervakning
• Skala och samtidighet
• Kallstartsskydd
• Prissättning
• Lagring av källkod
• Lokal utveckling
• Utplacering
• Tidsgränser och minnesgränser
• Hemlighetshantering
• Tillståndshantering
• Tillståndskänslig orkestrering
• Andra skillnader och överväganden

Språk som stöds

Programmeringsmodell

Händelseutlösare och bindningar

Behörigheter

Funktions-URL

Nätverkande

Observerbarhet och övervakning

Skalning och samtidighet

Kallstartsskydd

Prissättning

Lagring av källkod

Lokal utveckling

Driftsättning

Utgångstidsgränser och minnesgränser

Hemlighetshantering

Statushantering

Tillståndsbevarande orkestrering

Andra skillnader och överväganden

Skapa en migreringsplan

1. Välj viktiga arbetsbelastningar för ett konceptbevis.

   Börja med att välja en till två medelstora, icke-kritiska arbetsbelastningar från ditt totala lager. Dessa arbetsbelastningar utgör grunden för din proof-of-concept-migrering. Du kan testa processen och identifiera potentiella utmaningar utan att riskera större avbrott i verksamheten.

2. Testa iterativt och samla in feedback.

   Använd konceptbeviset för att samla in feedback, identifiera luckor och finjustera processen innan du skalar till större arbetsbelastningar. Den här iterativa metoden säkerställer att du tar itu med potentiella utmaningar och förfinar processen när du övergår till fullskalig migrering.

Skapa migreringstillgångarna

Det här steget är en övergångsfas för utveckling. Under den här fasen skapar du källkod, infrastruktur som kodmallar (IaC) och distributionspipelines för att representera arbetsbelastningen i Azure. Du måste anpassa funktionskoden för kompatibilitet och metodtips innan du kan utföra migreringen.

• Anpassa funktionskod, konfigurationsfiler och infrastruktur som kodfiler
• Justera konfigurationsinställningar
• Generera IaC-filer
• Använda verktyg för refaktorisering

Anpassa funktionskod, konfigurationsfiler och infrastruktur som kodfiler

Så här uppdaterar du koden så att den uppfyller kraven för Azure Functions-körning:

• Ändra koden så att den följer Azure Functions-programmeringsmodellen. Du kan till exempel anpassa dina funktionssignaturer så att de matchar det format som Azure Functions kräver. Mer information om funktionsdefinition och körningskontext finns i Utvecklarguider för Azure Functions.

• Använd Azure Functions-tilläggspaketet för att hantera olika bindningar och utlösare som liknar AWS-tjänster. För .NET-program bör du använda lämpliga NuGet-paket i stället för tilläggspaketet.

• Använd tilläggspaketet för att integrera med andra Azure-tjänster som Azure Storage, Azure Service Bus och Azure Cosmos DB utan att behöva konfigurera varje bindning manuellt via SDK:er. Mer information finns i Ansluta funktioner till Azure-tjänster med hjälp av bindningar och Azure Functions-bindningsuttrycksmönster.

Följande kodfragment är exempel på vanlig SDK-kod. AWS Lambda-koden mappar till motsvarande utlösare, bindningar eller SDK-kodfragment i Azure Functions.

Läsa från Amazon S3 jämfört med Azure Blob Storage

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()}`);
});

Skriva till Amazon Simple Queue Service (SQS) eller Azure Queue Storage

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}`);
}); 

Skrivning till DynamoDB kontra 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)}`); 
}); 
}); 

Amazon CloudWatch-händelser jämfört med en Azure-timer-trigger

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) jämfört med en Azure Event Grid-utlösare

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 jämfört med en Azure Event Hubs-utlösare

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}`);  
});  
});

Se följande GitHub-lagringsplatser för att jämföra AWS Lambda-kod och Azure Functions-kod:

• AWS Lambda-kod
• Azure Functions-kod
• Azure-exempellagringsplats, som innehåller start-, IaC- och slutpunkt till slutpunkt-exempel för Azure Functions

Justera konfigurationsinställningar

Kontrollera att funktionens timeout- och minnesinställningar är kompatibla med Azure Functions. Mer information om konfigurerbara inställningar finns ihost.json referens för Azure Functions.

Följ de rekommenderade metodtipsen för behörigheter, åtkomst, nätverk och distributionskonfigurationer.

Konfigurera behörigheter

Följ metodtipsen när du konfigurerar behörigheter för dina funktionsappar. Mer information finns i Konfigurera funktionsappen och lagringskontot med hanterad identitet.

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}'
  }
}

Mer information finns i rbac.bicep.

Konfigurera nätverksåtkomst

Azure Functions stöder integrering av virtuella nätverk, vilket ger funktionsappen åtkomst till resurser i ditt virtuella nätverk. Efter integreringen dirigerar appen utgående trafik via det virtuella nätverket. Sedan kan din app komma åt privata slutpunkter eller resurser med hjälp av regler som endast tillåter trafik från specifika undernät. Om målet är en IP-adress utanför det virtuella nätverket är käll-IP-adressen en av adresserna som anges i appens egenskaper, såvida du inte konfigurerar en NAT-gateway.

När du aktiverar integrering av virtuella nätverk för dina funktionsappar följer du metodtipsen i TSG för integrering av virtuella nätverk för webbappar och funktionsappar.

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
  }
}

Mer information finns i VNet.bicep och storage-PrivateEndpoint.bicep.

Konfigurera inställningar för distribution

Utrullningar följer en enda väg. När du har skapat projektkoden och komprimerat den till ett programpaket distribuerar du den till en Blob Storage-container. När den startar hämtar appen paketet och kör funktionskoden från det. Som standard fungerar samma lagringskonto som lagrar interna värdmetadata, till exempel AzureWebJobsStorage, som distributionscontainer. Du kan dock använda ett alternativt lagringskonto eller välja önskad autentiseringsmetod genom att konfigurera appens distributionsinställningar. Mer information finns i Information om distributionsteknik och Konfigurera distributionsinställningar.

Generera IaC-filer

• Använd verktyg som Bicep, Azure Resource Manager-mallar eller Terraform för att skapa IaC-filer för att distribuera Azure-resurser.

• Definiera resurser som Azure Functions, lagringskonton och nätverkskomponenter i dina IaC-filer.

• Använd den här IaC-exempellagringsplatsen för exempel som använder Azure Functions-rekommendationer och metodtips.

Använda verktyg för refaktorisering

Använd verktyg som GitHub Copilot i VS Code för hjälp med kodrefaktorisering, manuell refaktorisering för specifika ändringar eller andra migreringshjälpmedel.

Följande artiklar innehåller specifika exempel och detaljerade steg för att underlätta migreringsprocessen:

• Azure för AWS-proffs
• Utveckla Azure Functions lokalt med hjälp av Core Tools

Utveckla en stegvis process för day-0-migrering

Utveckla redundans- och återställningsstrategier för migreringen och testa dem noggrant i en förproduktionsmiljö. Vi rekommenderar att du utför testning från slutpunkt till slutpunkt innan du slutligen övergår från AWS Lambda till Azure Functions.

• Verifiera funktioner

  • Koda och testa Azure Functions lokalt.

  • Testa varje funktion noggrant för att säkerställa att den fungerar som förväntat. Dessa tester bör omfatta indata/utdata, händelseutlösare och bindningsverifiering.

  • Använd verktyg som curl- eller REST-klienttillägg i VS Code för att skicka HTTP-begäranden för HTTP-utlösta funktioner.

  • För andra utlösare, till exempel timers eller köer, kontrollerar du att utlösarna utlöses korrekt och att funktionerna körs som förväntat.

• Verifiera prestanda

  • Utför prestandatestning för att jämföra den nya Azure Functions-distributionen med den tidigare AWS Lambda-distributionen.

  • Övervaka mått som svarstid, körningstid och resursförbrukning.

  • Använd Application Insights för övervakning, logganalys och felsökning under testfasen.

• Felsök med hjälp av funktionen diagnostisera och lösa problem

  Använd funktionen diagnostisera och lösa problem i Azure-portalen för att felsöka funktionsappen. Det här verktyget innehåller en uppsättning diagnostikfunktioner som hjälper dig att snabbt identifiera och lösa vanliga problem, till exempel programkrascher, prestandaförsämring och konfigurationsproblem. Följ de guidade felsökningsstegen och rekommendationerna som verktyget ger för att åtgärda problem som du identifierar.

Utvärdera sluttillståndet för den migrerade arbetsbelastningen

Innan du inaktiverar resurser i AWS måste du vara säker på att plattformen uppfyller nuvarande arbetsbelastningsförväntningar och att ingenting blockerar arbetsbelastningsunderhåll eller vidareutveckling.

Distribuera och testa funktioner för att verifiera deras prestanda och korrekthet.

Distribuera till Azure

Distribuera arbetsbelastningar med hjälp av VS Code-publiceringsfunktionen. Du kan också distribuera arbetsbelastningar från kommandoraden med hjälp av Azure Functions Core Tools eller Azure CLI. Azure DevOps och GitHub Actions använder också One Deploy.

• Azure Functions Core Tools: Distribuera din funktionsapp med kommandot med hjälp av func azure functionapp publish <FunctionAppName>.

• Pipelines för kontinuerlig integrering och kontinuerlig distribution (CI/CD): Konfigurera en CI/CD-pipeline med hjälp av tjänster som GitHub Actions, Azure DevOps eller ett annat CI/CD-verktyg.

  Mer information finns i Kontinuerlig leverans med hjälp av GitHub Actions eller Kontinuerlig leverans med Azure Pipelines.

Utforska exempel på migreringsscenarier

Använd MigrationGetStarted-repon som mall för att börja med din prototyp. Den här lagringsplatsen innehåller ett Azure Functions-projekt som är redo att distribueras med infrastrukturen och källkodsfilerna som hjälper dig att komma igång.

Om du föredrar att använda Terraform använder du MigrationGetStarted-Terraform i stället.

Optimera och övervaka programmets prestanda i Azure

När du har migrerat din arbetsbelastning rekommenderar vi att du utforskar fler funktioner i Azure. De här funktionerna kan hjälpa dig att uppfylla framtida arbetsbelastningskrav och minska luckor.

Använda Application Insights för övervakning och felsökning

Aktivera Application Insights för din funktionsapp för att samla in detaljerade telemetridata för övervakning och felsökning. Du kan aktivera Application Insights via Azure-portalen eller i funktionsappens host.json konfigurationsfil. När du har aktiverat Application Insights kan du:

• Samla in telemetridata. Application Insights innehåller olika telemetridata, till exempel begärandeloggar, prestandamått, undantag och beroenden.

• Analysera loggar och mått. Få åtkomst till Application Insights-instrumentpanelen från Azure-portalen för att visualisera och analysera loggar, mått och andra telemetridata. Använd de inbyggda verktygen för att skapa anpassade frågor och visualisera data för att få insikter om funktionsappens prestanda och beteende.

• Konfigurera aviseringar. Konfigurera aviseringar i Application Insights för att meddela dig om kritiska problem, prestandaförsämring eller specifika händelser. De här aviseringarna hjälper dig att proaktivt övervaka och snabbt svara på problem.

Optimera för kostnad och prestanda

• Skalning och prestandaoptimering:

  • Använd funktioner för automatisk skalning för att effektivt hantera varierande arbetsbelastningar.

  • Optimera funktionskoden för att förbättra prestanda genom att minska körningstiden, optimera beroenden och använda effektiva kodningsmetoder.

  • Implementera cachelagringsstrategier för att minska upprepad bearbetning och svarstid för data som används ofta.

• Kostnadshantering:

  • Använd Microsoft Cost Management-verktyg för att övervaka och analysera dina Azure Functions-kostnader.

  • Konfigurera budgeterings- och kostnadsaviseringar för att hantera och förutsäga utgifter effektivt.