InMy.Live

🔰 Débutants qui découvrent AWS CDK, veuillez consulter mes articles précédents un par un dans cette série.

Si vous avez raté l’article précédent, retrouvez-le avec les liens ci-dessous.

🔁 Message précédent original sur 🔗 Dev Post

🔁 Republié le post précédent à 🔗 dev à @aravindvcyber

Dans cet article, introduisons une passerelle API devant notre fonction lambda de base que nous avons créée dans notre dernier article ci-dessus répertorié ci-dessus.

Pourquoi API Gateway dans notre solution

Étant donné que notre lambda n’est accessible que dans notre environnement aws, nous avons besoin de cette configuration de passerelle API qui aidera à exposer un point de terminaison HTTP public que n’importe qui sur Internet peut atteindre avec un client HTTP.

En outre, une passerelle API peut bloquer les demandes inappropriées sans appeler les fonctions Lambda backend, lorsque les vérifications d’autorisation échouent. API Gateway peut ainsi réduire les coûts d’appel Lambda élevés et peut également décharger la validation des demandes de votre fonction Lambda, en fonction des besoins.

Commençons par éditer le lib/common-event-stact.ts déposer. Ici, importons les modules de aws-cdk-lib/aws-apigateway comme agigw.

 // this defines an new API Gateway REST API resource backed by our "eventEntry" function.
    const eventGateway = new apigw.LambdaRestApi(this, 'EventEndpoint', {
      handler: eventEntry
    });

Quand tu cours cdk diffvous pouvez vous attendre à un journal similaire sur les nouvelles ressources à créer ainsi que sur les modifications de stratégie IAM impliquées.

IAM Statement Changes

    Resource                                             Effect  Action                 Principal                                            Condition                                           

 +  ${EventEndpoint/CloudWatchRole.Arn}                  Allow   sts:AssumeRole         Service:apigateway.amazonaws.com                                                                         

 +  ${EventEntryHandler.Arn}                             Allow   lambda:InvokeFunction  Service:apigateway.amazonaws.com                     "ArnLike": {                                        
                                                                                                                                               "AWS:SourceArn": "arn:${AWS::Partition}:execute-a 
                                                                                                                                             pi:${AWS::Region}:${AWS::AccountId}:${EventEndpoint 
                                                                                                                                             82CBF40A}/${EventEndpoint/DeploymentStage.prod}/*/* 
                                                                                                                                             "                                                   
                                                                                                                                             }                                                   
 +  ${EventEntryHandler.Arn}                             Allow   lambda:InvokeFunction  Service:apigateway.amazonaws.com                     "ArnLike": {                                        
                                                                                                                                               "AWS:SourceArn": "arn:${AWS::Partition}:execute-a 
                                                                                                                                             pi:${AWS::Region}:${AWS::AccountId}:${EventEndpoint 
                                                                                                                                             82CBF40A}/test-invoke-stage/*/*"                    
                                                                                                                                             }                                                   
 +  ${EventEntryHandler.Arn}                             Allow   lambda:InvokeFunction  Service:apigateway.amazonaws.com                     "ArnLike": {                                        
                                                                                                                                               "AWS:SourceArn": "arn:${AWS::Partition}:execute-a 
                                                                                                                                             pi:${AWS::Region}:${AWS::AccountId}:${EventEndpoint 
                                                                                                                                             82CBF40A}/${EventEndpoint/DeploymentStage.prod}/*/" 
                                                                                                                                             }                                                   
 +  ${EventEntryHandler.Arn}                             Allow   lambda:InvokeFunction  Service:apigateway.amazonaws.com                     "ArnLike": {                                        
                                                                                                                                               "AWS:SourceArn": "arn:${AWS::Partition}:execute-a 
                                                                                                                                             pi:${AWS::Region}:${AWS::AccountId}:${EventEndpoint 
                                                                                                                                             82CBF40A}/test-invoke-stage/*/"                     
                                                                                                                                             }                                                   

IAM Policy Changes

    Resource                         Managed Policy ARN                                                                      

 +  ${EventEndpoint/CloudWatchRole}  arn:${AWS::Partition}:iam::aws:policy/service-role/AmazonAPIGatewayPushToCloudWatchLogs 

(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)

Resources
[+] AWS::ApiGateway::RestApi EventEndpoint EventEndpoint82CBF40A 
[+] AWS::IAM::Role EventEndpoint/CloudWatchRole EventEndpointCloudWatchRole4E252113 
[+] AWS::ApiGateway::Account EventEndpoint/Account EventEndpointAccount1A8CF478 
[+] AWS::ApiGateway::Deployment EventEndpoint/Deployment EventEndpointDeployment9E6BA6B96f1395a2ccbaf49542e68813f77a19e7 
[+] AWS::ApiGateway::Stage EventEndpoint/DeploymentStage.prod EventEndpointDeploymentStageprod2ED092D9 
[+] AWS::ApiGateway::Resource EventEndpoint/Default/{proxy+} EventEndpointproxyCBF9AFD2 
[+] AWS::Lambda::Permission EventEndpoint/Default/{proxy+}/ANY/ApiPermission.CommonEventStackEventEndpointB06FCC50.ANY..{proxy+} EventEndpointproxyANYApiPermissionCommonEventStackEventEndpointB06FCC50ANYproxy3F9D95E2 
[+] AWS::Lambda::Permission EventEndpoint/Default/{proxy+}/ANY/ApiPermission.Test.CommonEventStackEventEndpointB06FCC50.ANY..{proxy+} EventEndpointproxyANYApiPermissionTestCommonEventStackEventEndpointB06FCC50ANYproxy75C60637 
[+] AWS::ApiGateway::Method EventEndpoint/Default/{proxy+}/ANY EventEndpointproxyANY74421EDC 
[+] AWS::Lambda::Permission EventEndpoint/Default/ANY/ApiPermission.CommonEventStackEventEndpointB06FCC50.ANY.. EventEndpointANYApiPermissionCommonEventStackEventEndpointB06FCC50ANY7F8C8232 
[+] AWS::Lambda::Permission EventEndpoint/Default/ANY/ApiPermission.Test.CommonEventStackEventEndpointB06FCC50.ANY.. EventEndpointANYApiPermissionTestCommonEventStackEventEndpointB06FCC50ANYC6DC815A 
[+] AWS::ApiGateway::Method EventEndpoint/Default/ANY EventEndpointANY8620E9D3

Résumant la sortie ci-dessus 💥

Pour résumer ce qui précède, comprenons ce qui se passe dans le backend comme suit et sera publié.

• Une nouvelle stratégie IAM est créée CloudWatchRole et supposé envoyer les journaux à cloudwatch depuis apigateway.
• Une étape de déploiement prod est configuré, nous pouvons avoir plusieurs étapes pour tester les fonctionnalités prématurément avec cela, sans affecter l’étape de production.
• Les autorisations de ressources sont configurées avec les privilèges nécessaires pour tout Resource path, par défaut un chemin de ressource gourmand {proxy+} pour le point de terminaison normal et le point de terminaison de test pour cette API de repos.
• Les autorisations de ressources sont configurées avec les privilèges nécessaires pour tout method pour le point de terminaison normal et le point de terminaison de la variante de test pour cette API de repos.

La compréhension approfondie des concepts ci-dessus nous aidera lorsque nous restreindrons davantage la passerelle API à l’avenir pour des points de terminaison similaires basés sur le repos.

Maintenant, exécutons ce déploiement et vérifions les résultats.

Avant cela, permettez-moi de faire un autre changement dans notre lambda pour afficher le message approprié.

exports.receiver = async function(event:any) {
  console.log("request:", JSON.stringify(event, undefined, 2));
  return {
    statusCode: 200,
    headers: { "Content-Type": "text/plain" },
    body: `Message Received in lambda: ${JSON.stringify(event.body)}\n`
  };
};

cdk deploy CommonEventStack

   CommonEventStack

  Deployment time: 57.21s

Outputs:
CommonEventStack.EventEndpointA893C53E = https://lwo***********uvhg.execute-api.ap-south-1.amazonaws.com/prod/
Stack ARN:
arn:aws:cloudformation:ap-south-1:575066707855:stack/CommonEventStack/93688c10-a10a-11ec-b942-0ad3136ae540

  Total time: 68.43s

🏃 Tests de boucles

Lorsque nous effectuons une boucle pour vérifier ce point final de repos, voyons ce que nous obtenons.

curl https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod/

Message Received: null

Ici, nous réussissons à envoyer un message au lambda et nous avons également obtenu une sortie. Bien que nous ayons null parce que nous n’avons jamais envoyé de corps dans notre initiale GET demande.

Envoyons maintenant un message via le corps de la demande du client dans une demande de publication.

curl -H "Content-Type: application/json" -d '{ "message": "client message"}' -X POST https://********.execute-api.ap-south-1.amazonaws.com/prod/

Message Received in lambda: "{ \"message\": \"client message\"}"

Nous avons configuré avec succès la passerelle agi, alors vérifions-la dans la console et testons-la également dans la console aws.

Passerelle API dans la console AWS

Inspecter le chemin du point de terminaison et les méthodes autorisées

Tester la requête POST d’invocation avec message

Affiner la passerelle Api créée ci-dessus

Maintenant, affinons la passerelle api créée pour qu’elle soit disponible uniquement pour la méthode POST et un chemin de ressource spécifique uniquement.

Documentation de référence de l’API CDK 🐼

Avant de faire cela, nous devons utiliser la documentation de référence cdk api. Désormais, nous pouvons explorer cette documentation de référence pour choisir les paramètres et options nécessaires pour chaque construction de ressource de pile cdk.

Ici, si vous vous souvenez, nous avons importé aws-cdk-lib/aws-apigatewaynous devons apprendre à utiliser la bibliothèque de construction à https://docs.aws.amazon.com/cdk/api/v2

Plus précisément, nous devons naviguer vers https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway-readme.html. Ici, nous pourrions trouver la documentation nécessaire pour la construction apigateway et comment utiliser ses propriétés et ses méthodes, avec des exemples appropriés.

Spécifiez le bon chemin de ressource et la bonne méthode 🔦

Supprimons d’abord cette définition de chemin de ressource de proxy gourmand.

const eventGateway = new apigw.LambdaRestApi(this, 'EventEndpoint', {
      handler: eventEntry,
      proxy: false
    });

Ici, l’attribut proxy supprime la définition de chemin de ressource gourmande par défaut.

Déclarons maintenant un chemin de ressource disponible comme dans l’exemple ci-dessous.

 const eventHandler: apigw.LambdaIntegration = new apigw.LambdaIntegration(eventEntry);
    const event = eventGateway.root.addResource('event');

    const eventMethod: apigw.Method = event.addMethod('POST', eventHandler, {  
       apiKeyRequired: false
    });

Maintenant, nous n’exposons et n’autorisons que le chemin et la méthode de ressource spécifiques avec succès.

Lorsque nous accédons au chemin de ressource de base avec des méthodes interdites 🔦

Alors que nous pouvons accéder à notre API spécifique avec succès, notez la différence dans le full path avec la méthode autorisée.

Plan d’utilisation et clés API 🔔

Un plan d’utilisation spécifie qui peut accéder à une ou plusieurs étapes et méthodes d’API déployées, et la fréquence à laquelle elles sont accessibles.

Le plan utilise des clés API pour identifier les clients API et mesurer l’accès aux étapes API associées pour chaque clé en conséquence. Les plans d’utilisation permettent également de configurer des limites de limitation et des limites de quota qui sont appliquées sur des clés d’API client individuelles.

L’exemple suivant montre comment créer et associer un plan d’utilisation et une clé API :

const eventMethod: apigw.Method = event.addMethod('POST', eventHandler, {  
       apiKeyRequired: true,
    });

Pour utiliser une clé API, il est nécessaire de configurer un plan d’utilisation, quelque chose de similaire à l’exemple ci-dessous, puis nous pouvons l’associer à la clé que nous venons de créer.

const plan = eventGateway.addUsagePlan('UsagePlan', {
        name: 'Workshop',
        description: 'For Workshop',
        throttle: {
          burstLimit: 5,
          rateLimit: 10,
        },
        quota: {
          limit: 100,
          period: apigw.Period.DAY
        }
    });

    const normalUserKey = eventGateway.addApiKey('ApiKey',{
        apiKeyName: 'av-api-key',
        value: 'av-api-key-value-********',
    });
    plan.addApiKey(normalUserKey);

Niveau phase de déploiement affinage du plan d’utilisation 🌻

Le réglage fin du plan d’utilisation ci-dessus à différentes étapes de déploiement pour la méthode spécifique en plus et l’inclusion de limites d’accélération au niveau de la méthode permettent un meilleur contrôle des limites de consommation d’API et une plus grande utilisation des ressources avec plusieurs clients sur la base d’un contrat.

 plan.addApiStage({
      stage: eventGateway.deploymentStage,
      throttle: [
        {
          method: eventMethod,
          throttle: {
            rateLimit: 3,
            burstLimit: 2
          }
        }
      ]
    });

Limitation de l’api avec débit et limite de rafale 🐇

Vous pouvez contrôler efficacement le taux du nombre d’appels par seconde en limitant le débit avant que la passerelle ne refuse toute demande supplémentaire à l’entrée elle-même.

• La limite de rafale définit le nombre de requêtes que votre API peut gérer simultanément.
• La limite de débit définit le nombre de requêtes autorisées par seconde.

 throttle: {
            rateLimit: 3,
            burstLimit: 2
          }

Limite de quota 🐡

La limite de quota permet de définir le nombre cumulé de requêtes client reçues par la passerelle API avant que la limite de la passerelle ne soit dépassée.

Généralement, aws fournit un certain quota fixe pour chaque service par région, cela peut être géré efficacement en réservant une partie à chaque plan d’utilisation comme vous le souhaitez. Cela peut également vérifier pour limiter la consommation d’API utilisateur externe, en fonction de leur niveau de service.

 quota: {
      limit: 5,
      period: apigw.Period.DAY
      }

Une fois le quota alloué à l’utilisateur de la clé API dépassé, les réponses d’erreur sont envoyées.

Évaluer la clé API limitée 🐠

Dans certains scénarios où vous devez créer une seule clé API et configurer la limitation de débit pour celle-ci, vous pouvez utiliser RateLimitedApiKey. Cette construction vous permet de spécifier des propriétés de limitation de débit qui doivent être appliquées uniquement à la clé API en cours de création. La clé API créée a les limites de taux spécifiées, telles que les quotas et les limitations, appliquées, même sans aucune association à un plan d’utilisation.

const rateLimitedKey = new apigw.RateLimitedApiKey(this, 'rate-limited-api-key', {
       apiKeyName: 'av-rate-limited-api-key',
        value: 'av-api-key-value-dreatenbwebrwiukjwnrn',
    customerId: 'external-client',
    resources: [eventGateway],
    quota: {
      limit: 5,
      period: apigw.Period.DAY
      },
      throttle: {
        rateLimit: 2,
        burstLimit: 1
      }
    });
    plan.addApiKey(rateLimitedKey);

Nous pouvons maintenant vérifier la même chose dans la console API, où nous pouvons trouver qu’un nouveau plan est créé pour la clé API nouvellement créée. Pour un contrôle plus précis pour les utilisateurs individuels ne faisant pas partie d’autres plans d’utilisation.

Importation des clés et plans d’utilisation existants 🐝

En plus de cela, nous pouvons également importer les clés et le plan d’utilisation existants dans nos ressources de pile en suivant les exemples ci-dessous.

les plans d’utilisation peuvent être importés dans une application CDK à l’aide de son identifiant.

const importedUsagePlan = apigateway.UsagePlan.fromUsagePlanId(this, 'imported-usage-plan', '<usage-plan-key-id>');

Les clés API peuvent également être importées dans une application CDK à l’aide de son identifiant.

const importedKey = apigateway.ApiKey.fromApiKeyId(this, 'imported-key', '<api-key-id>');

Nous ajouterons plus de connexions à cette passerelle api et lambda et la rendrons plus utilisable dans les prochains articles, restez abonné.

Nous avons notre prochain article en sans serveur, consultez

🎉 Merci pour votre soutien ! 🙏

Ce serait vraiment génial si vous aimez Buy Me a Coffee, pour aider à stimuler mes efforts.

🔁 Message original sur 🔗 Dev Post

🔁 Republié à 🔗 dev à @aravindvcyber