aws sdk delphi Téléchargement - aws sdk delphi Source Code Download

AWS SDK pour Delphi

Le SDK AWS pour Delphi permet aux développeurs de Delphi de travailler facilement avec les services Web d'Amazon et de créer des solutions évolutives avec Amazon SES, Amazon SQS, etc. Il s'agit d'un SDK non officiel basé sur le SDK AWS officiel pour .NET. Des exemples de projets peuvent être trouvés dans AWS SDK pour le référentiel d'échantillons Delphi.

Services soutenus

Il s'agit de la liste des services AWS actuellement pris en charge par le SDK. Plus sera ajouté au fil du temps:

Amazon Lex: AI conversationnel pour Chatbox
Amazon Polly: texte à la parole
Amazon Rekognition: analyse d'image et vidéo
Amazon S3: Service de stockage simple
Amazon SES: API du service de messagerie simple (classique)
Amazon SES V2: API du service de messagerie simple v2
Amazon SNS: service de notification simple
Amazon SQS: service de file d'attente simple
Amazon traduit: traduction de texte

Rapport de bogue et demandes de fonctionnalités

Veuillez utiliser la page des problèmes GitHub pour signaler les problèmes ou demander des fonctionnalités.

Versions et plateformes de Delphi prises en charge

AWS SDK pour Delphi prend en charge toutes les versions récentes Delphi depuis Delphi 10.3 Rio (IE, Delphi 10.4 Sydney, Delphi 11, Delphi 12, etc.) et prend en charge toutes les plates-formes disponibles dans ces versions Delphi: Windows, Linux, Android, iOS et macOS.

Bibliothèques requises

AWS SDK pour Delphi ne nécessite aucune bibliothèque tierce, elle est écrite en code Delphi 100% natif et fonctionne sur toutes les réseaux de versions de Delphi prises en charge.

Installation

Vous pouvez installer la bibliothèque en effectuant une installation Manuall.

Installation manuelle

Pour chaque plate-forme différente, vous souhaitez installer le SDK:

Open AWSPackages.groupproj Group de projet dans votre IDE Delphi.
Ajoutez le dossier de sortie de la plate-forme au chemin de bibliothèque de plate-forme Delphi. Par exemple, si vous construisez pour Delphi 12, Win32, ajoutez le dossier <sdk_folder>/packages/d12/Win32/Release au chemin de bibliothèque Delphi 12, Win32.
Construisez tous les packages pour la plate-forme que vous souhaitez installer, en mode libération.

Utilisation du SDK

Chaque service Web Amazon possède son propre package et schéma de nom d'unité, qui est AWS<service>.dproj et AWS.<service>.*.pas , respectivement. Par exemple, pour Amazon SQS (Simple Queue Service), le nom du package est AWSSQS.dproj et le nom d'unité est AWS.SQS.pas (et toutes les autres unités du package suivent le même modèle, comme AWS.SQS.Client.pas ou AWS.SQS.ClientIntf.pas .

La plupart des types dont vous avez besoin seront dans l'unité principale, ce qui, par exemple, est AWS.SQS . C'est donc la seule unité dont vous aurez besoin pour utiliser la plupart des fonctions. De là, vous pouvez accéder à toutes les opérations API disponibles. Chaque méthode d'opération reçoit une interface de demande et renvoie une interface de réponse.

En résumé, c'est le processus pour effectuer des demandes d'API:

Utilisez l'unité principale du service, par exemple AWS.SQS ;
Instancier l'interface client ( TAmazonSQSClient );
Créer et remplir la demande;
Méthode de l'opération d'appel passant la demande pour recevoir la réponse;
Traiter la réponse.

Les exemples suivants reçoivent un message d'une file d'attente SQS et sortent l'ID et le corps de chaque message reçu:

 // 1. Use main unit
uses AWS.SQS;

procedure WriteMessageIds ( const QueueUrl: string);
var
  Client: IAmazonSQS;
  Response: IReceiveMessageResponse;
  Request: IReceiveMessageRequest;
  Msg: AWS.SQS.TMessage;
begin
  // 2. Instantiate client interface
  Client := TAmazonSQSClient.Create;

  // 3. Create and fill the request
  Request := TReceiveMessageRequest.Create;
  Request.QueueUrl := QueueUrl;

  // 4. Call operation method passing the request to receive the response;
  Response := Client.ReceiveMessage(Request);

  // 5. Process the response
  for Msg in Response.Messages do
  begin
    WriteLn(Msg.MessageId);
    WriteLn(Msg.Body);
    WriteLn;
  end ;
end ;

L'exemple suivant envoie un e-mail à l'adresse spécifiée en utilisant le sujet et le message spécifié:

 // 1. Use main unit
uses AWS.SES;

procedure SendEmail ( const Recipient, Subject, Content: string);
var
  Client: IAmazonSimpleEmailService;
  Request: ISendEmailRequest;
  Response: ISendEmailResponse;
begin
  // 2. Instantiate client interface
  Client := TAmazonSimpleEmailServiceClient.Create;

  // 3. Create and fill the request
  Request := TSendEmailRequest.Create;
  Request.Source := SenderEmail; 
  Request.Destination := TDestination.Create;
  Request.Destination.ToAddresses.Add(Recipient);
  Request.Message := TMessage.Create(
    TContent.Create(Subject),
    TBody.Create(TContent.Create(Content)));

  // 4. Call operation method passing the request to receive the response;
  Response := Client.SendEmail(Request);

  // 5. Process the response
  WriteLn(Response.MessageId);
end ;

Dans tous les objets de demande, les listes et les dictionnaires sont déjà instanciés, tandis que les autres objets associés ne le sont pas. Vous n'avez pas besoin de détruire une interface ou un objet transmis ou reçu des opérations, ou ajouté aux demandes. Certaines opérations ont des méthodes surchargées qui reçoivent moins de paramètres bruts au lieu de l'objet de demande complet, pour une utilisation plus simple.

Pour plus d'informations sur les opérations disponibles, veuillez vous référer à la documentation API du service Amazon que vous essayez d'utiliser. Ou, bien sûr, utilisez l'achèvement du code Delphi pour trouver toutes les méthodes disponibles dans chaque client de service.

Exemples de services spécifiques

Amazon SNS

Vous pouvez utiliser entièrement Amazon SNS: Service de notification simple à partir du SDK AWS pour Delphi. L'unité principale est AWS.SNS . Vous trouvez trouver des informations plus détaillées dans cet article sur l'utilisation d'Amazon SNS avec AWS SDK pour Delphi, et bien sûr, vous pouvez vous référer à la référence API Amazon SNS elle-même.

Création du client:

 var
  Client: IAmazonSimpleNotificationService;
begin
  Client := TAmazonSimpleNotificationServiceClient.Create;
end ;

Obtenez ARN pour tous les sujets existants:

 function GetAllTopics (AllTopics: TList<string>);
var
  ListRequest: IListTopicsRequest;
  ListResponse: IListTopicsResponse;
  Topic: TTopic;
begin
  ListRequest := TListTopicsRequest.Create;
  repeat
    ListResponse := Client.ListTopics(ListRequest);
    for Topic in ListResponse.Topics do
      AllTopics.Add(Topic.TopicArn);
    ListRequest.NextToken := ListResponse.NextToken;
  until ListRequest.NextToken = ' ' ;
end ;

Créez un sujet, obtenez son ARN, définissez / obtenez ses attributs et supprimez le sujet:

 var
  Response: ICreateTopicResponse;
  TopicArn: string;
  SetAttrRequest: ISetTopicAttributesRequest;
  GetAttrResponse: IGetTopicAttributesResponse;
begin
  // create new topic and get ARN
  Response := Client.CreateTopic( ' test-name ' );
  TopicArn := Response.TopicArn;

  // set topic attribute
  SetAttrRequest := TSetTopicAttributesRequest.Create(TopicArn, ' DisplayName ' , ' My topic ' );
  Client.SetTopicAttributes(SetAttrRequest);

  // verify topic attributes
  GetAttrResponse := Client.GetTopicAttributes(TopicArn);
  DisplayName := GetAttrResponse.Attributes[ ' DisplayName ' ]);

  // delete new topic
  Client.DeleteTopic(TopicArn);
end ;

Abonnez-vous un sujet à une file d'attente SQS via une URL de file d'attente, en ajoutant les autorisations appropriées:

 function SubscribeQueue (Client: IAmazonSimpleNotificationService;
  const TopicArn: string; SQSClient: IAmazonSQS; const SQSQueueUrl: string): string; 
var
  GetAttrResponse: IGetQueueAttributesResponse;
  GetAttrRequest: IGetQueueAttributesRequest;
  SQSQueueArn: string;
  Policy: TPolicy;
  PolicyStr: string;
  TopicArn: string;
  SetAttrRequest: ISetQueueAttributesRequest;
begin
  // Get the queue's existing policy and ARN
  GetAttrRequest := TGetQueueAttributesRequest.Create;
  GetAttrRequest.QueueUrl := SQSQueueUrl;
  GetAttrRequest.AttributeNames.Add(TSQSConsts.ATTRIBUTE_ALL);
  GetAttrResponse := SQSClient.GetQueueAttributes(GetAttrRequest);
  SQSQueueArn :=  GetAttrResponse.Attributes[ ' QueueArn ' ];

  if  GetAttrResponse.Attributes.TryGetValue( ' Policy ' , PolicyStr) then
    Policy := TPolicy.FromJson(PolicyStr)
  else
    Policy := TPolicy.Create;
  try
    SetLength(Result, 0 );
    if not HasSQSPermission(Policy, TopicArn, SQSQueueArn) then
      AddSQSPermission(Policy, TopicArn, SQSQueueArn);

    Result := Client.Subscribe(TopicArn, ' sqs ' , SQSQueueArn).SubscriptionArn;

    SetAttrRequest := TSetQueueAttributesRequest.Create;
    SetAttrRequest.QueueUrl := SQSQueueUrl;
    SetAttrRequest.Attributes.Add( ' Policy ' , Policy.ToJson);
    SQSClient.SetQueueAttributes(SetAttrRequest);
  finally
    Policy.Free;
  end ;
end ;

Abonnez-vous un sujet pour envoyer un e-mail et retournez l'abonnement ARN:

 function SubscribeTopic ( const TopicArn, EmailAddress: string): string;
var
  Latest: TDateTime;
  Response: IListSubscriptionsByTopicResponse;
begin
  // subscribe an email address to the topic
  Client.Subscribe(TSubscribeRequest.Create(TopicArn, ' email ' , EmailAddress));

  // wait until subscription has been confirmed, wait time for two minutes
  Latest := IncMinute(Now, 2 );
  while Now < Latest do
  begin
    // get subscriptions for topic
    Response := Client.ListSubscriptionsByTopic(TopicArn);

    // test whether the subscription has been confirmed
    if Response.Subscriptions[ 0 ].SubscriptionArn <> ' PendingConfirmation ' then
      Exit(Response.Subscriptions[ 0 ].SubscriptionArn);

    // wait
    Sleep( 15 * 1000 );
  end ;
end ;

Publiez un message à un sujet:

  // publish a message to the topic
  Client.Publish(TPublishRequest.Create(TopicArn, ' Test message ' , ' Subject ' ));

Supprimer un abonnement:

  // delete the subscription
  Client.Unsubscribe(SubArn);

Analyser un message SNS de JSON et valider la signature:

 function GetMessage ( const Json: string): AWS.SNS.Message.TMessage;
begin
  Result := AWS.SNS.Message.TMessage.ParseMessage(Json);
  if not Result.IsMessageSignatureValid then
    raise Exception.Create( ' Invalid message: bad signature ' );
end ;

Envoyez un SMS à un numéro de téléphone:

 var
  Client: IAmazonSimpleNotificationService;
  Request: IPublishRequest;
begin
  Client := TAmazonSimpleNotificationServiceClient.Create;
  Request := TPublishRequest.Create;
  Request.PhoneNumber := ' +184298765321 ' ;
  Request.Message := ' Hello from AWS SDK for Delphi! ' ;
  Client.Publish(Request);
end ;

Informations d'identification

Le SDK AWS pour Delphi recherche des informations d'identification dans une certaine commande et utilise le premier ensemble disponible pour l'application actuelle.

Ordre de recherche d'identification

Des informations d'identification qui sont explicitement définies sur le client AWS Service, comme décrit dans l'accès à passer directement et les clés secrètes directement au client.
Un profil d'identification avec le nom spécifié par une valeur dans TAWSConfigs.AWSProfileName .
Un profil d'identification avec le nom spécifié par la variable d'environnement AWS_PROFILE .
Le profil [par défaut] des informations d'identification.

Résolution de profil

La propriété TAWSConfigs.AWSProfilesLocation contrôle la façon dont le SDK AWS pour Delphi trouve des profils d'identification. S'il est vide, il recherche le fichier d'identification AWS partagé dans l'emplacement par défaut. Si le profil n'est pas là, recherchez ~/.aws/config (linux ou macOS) ou %USERPROFILE%.awsconfig (windows). Si TAWSConfigs.AWSProfilesLocation contient le chemin d'accès à un fichier au format de fichier AWS Identials, le SDK recherche des informations d'identification uniquement dans le fichier spécifié pour un profil avec le nom spécifié.

Veuillez vous référer à la documentation AWS pour plus d'informations sur les paramètres du fichier des informations d'identification et les profils nommés.

Passer l'accès et les clés secrètes directement au client

Vous pouvez simplement passer l'ID de clé d'accès et la clé secrète directement dans le constructeur client:

  Client := TAmazonSQSClient.Create(myAccessKey, mySecretKey);

Bien que l'utilisation du profil d'identification soit recommandée car elle est plus facile à gérer et également compatible avec l'interface de ligne de commande AWS.

Tests

Important: n'exécutez pas les tests d'intégration sur un compte de production.

Des tests d'intégration peuvent être trouvés dans le projet Awstests . Ces tests supposent qu'un profil par défaut a été configuré pour les informations d'identification. Vous pouvez configurer des informations d'identification à l'aide de fichiers de configuration, de profils nommés ou de variables d'environnement.

Les tests sont conçus pour créer et supprimer les ressources nécessaires pour les tests, mais il est important de protéger vos données. N'exécutez pas ces tests sur des comptes contenant des données de production ou des ressources. Étant donné que les ressources AWS sont créées et supprimées lors de l'exécution de ces tests, des charges peuvent se produire. Pour réduire les frais qui se sont produits en exécutant les tests, concentrez-vous sur les ressources AWS qui ont un coût minimal.