aws sdk delphi Download - aws sdk delphi Source Code Download

AWS SDK für Delphi

Mit dem AWS SDK für Delphi können Delphi -Entwickler problemlos mit Amazon -Webdiensten zusammenarbeiten und skalierbare Lösungen mit Amazon SES, Amazon SQS und vielem mehr erstellen. Es ist ein nicht offizieller SDK, der auf dem offiziellen AWS SDK für .NET basiert. Beispielprojekte finden Sie in AWS SDK für Delphi Proben -Repository.

Unterstützte Dienste

Dies ist die Liste der AWS -Dienste, die derzeit vom SDK unterstützt werden. Weitere werden im Laufe der Zeit hinzugefügt:

Amazon Lex: Konversations -KI für Chatbox
Amazon Polly: Text zur Sprache
Amazon Rekognition: Bild- und Videoanalyse
Amazon S3: Einfacher Speicherdienst
Amazon SES: Einfache E -Mail -Service -API (Klassiker)
Amazon SES V2: Einfache E -Mail -Service -API V2
Amazon SNS: Einfacher Benachrichtigungsdienst
Amazon SQS: Einfacher Warteschlangenservice
Amazon Translate: Textübersetzung

Fehlerbericht und Feature -Anfragen

Bitte verwenden Sie die Seite mit GitHub -Problemen, um Probleme zu melden oder Funktionen anzufordern.

Unterstützte Delphi -Versionen und Plattformen

AWS SDK für Delphi unterstützt alle aktuellen Delphi -Versionen, da Delphi 10.3 Rio (dh, Delphi 10.4 Sydney, Delphi 11, Delphi 12 usw.) und alle Plattformen unterstützt, die in diesen Delphi -Versionen verfügbar sind: Windows, Linux, Android, IOS und MacOS.

Erforderliche Bibliotheken

AWS SDK für Delphi benötigt keine Bibliothek von Drittanbietern, sie ist in 100% nativem Delphi -Code geschrieben und funktioniert auf allen Skus unterstützten Delphi -Versionen.

Installation

Sie können die Bibliothek installieren und eine Manuall -Installation durchführen.

Manuelle Installation

Für jede verschiedene Plattform möchten Sie den SDK installieren:

Open AWSPackages.groupproj -Projektgruppe in Ihrer Delphi IDE.
Fügen Sie den Plattform -Ausgangsordner zum Delphi Platform Library -Pfad hinzu. Wenn Sie beispielsweise für Delphi 12, Win32 bauen, fügen Sie den Ordner <sdk_folder>/packages/d12/Win32/Release zu Delphi 12, Win32 -Bibliotheksweg hinzu.
Erstellen Sie alle Pakete für die Plattform, die Sie installieren möchten, im Release -Modus.

Verwenden des SDK

Jeder Amazon -Webdienst verfügt über ein eigenes Paket- und Einheitsnamenschema, das AWS<service>.dproj bzw. AWS.<service>.*.pas ist. Für Amazon SQS (einfacher Warteschlangenservice) lautet der Paketname AWSSQS.dproj und Einheitenname ist AWS.SQS.pas (und alle anderen Einheiten im Paket folgen gleichem Muster wie AWS.SQS.Client.pas oder AWS.SQS.ClientIntf.pas .

Die meisten Typen, die Sie benötigen, befinden sich in der Haupteinheit, beispielsweise AWS.SQS . Das ist also die einzige Einheit, die Sie benötigen, um die meisten Funktionen zu verwenden. Von dort aus können Sie auf alle verfügbaren API -Vorgänge zugreifen. Jede Betriebsmethode empfängt eine Anforderungsschnittstelle und gibt eine Antwortschnittstelle zurück.

Zusammenfassend ist dies der Prozess, um API -Anfragen auszuführen:

Verwenden Sie die Haupteinheit des Dienstes, z. B. AWS.SQS ;
Instantieren Sie die Client -Schnittstelle ( TAmazonSQSClient );
Erstellen und füllen Sie die Anfrage;
Anruf Betriebsmethode über die Anfrage zum Empfangen der Antwort;
Verarbeiten Sie die Antwort.

Die folgenden Beispiele erhalten eine Nachricht von einer SQS -Warteschlange und geben die ID und den Körper jeder empfangenen Nachricht aus:

 // 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 ;

Das folgende Beispiel sendet eine E-Mail an die angegebene Adresse mit dem angegebenen Betreff und der angegebenen Nachricht:

 // 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 ;

In allen Anforderungsobjekten sind bereits Listen und Wörterbücher so instanziiert, während andere zugehörige Objekte dies nicht tun. Sie müssen keine Schnittstelle oder Objekt zerstören, die an die Operationen übergeben oder empfangen werden oder zu Anforderungen hinzugefügt werden. Einige Operationen haben überlastete Methoden, die weniger Rohparameter anstelle des vollständigen Anforderungsobjekts erhalten, um eine einfachere Verwendung zu erhalten.

Weitere Informationen zu den verfügbaren Vorgängen finden Sie in der API -Dokumentation des Amazon -Dienstes, den Sie verwenden möchten. Oder verwenden Sie natürlich die Fertigstellung von Delphi Code, um alle in jedem Service -Client verfügbaren Methoden zu finden.

Beispiele für bestimmte Dienste

Amazon SNS

Sie können Amazon SNS: Simple Benachrichtigungsdienst von AWS SDK für Delphi voll verwenden. Haupteinheit ist AWS.SNS . In diesem Artikel finden Sie detailliertere Informationen zur Verwendung von Amazon SNS mit AWS SDK für Delphi. Natürlich können Sie sich auf die Amazon SNS -API -Referenz selbst verweisen.

Erstellen des Kunden:

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

Holen Sie sich ARN für alle vorhandenen Themen:

 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 ;

Erstellen Sie ein Thema, holen Sie sich das ARN, setzen Sie seine Attribute und löschen Sie das Thema:

 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 ;

Abonnieren Sie ein Thema einer SQS -Warteschlange über die Warteschlangen -URL und fügen Sie die richtigen Berechtigungen hinzu:

 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 ;

Abonnieren Sie ein Thema an eine E-Mail und senden Sie das Abonnement ARN zurück:

 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 ;

Veröffentlichen Sie eine Nachricht an ein Thema:

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

Ein Abonnement löschen:

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

Analysieren Sie eine SNS -Nachricht von JSON und validieren Sie die Signatur:

 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 ;

Senden Sie eine SMS -Nachricht an eine Telefonnummer:

 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 ;

Anmeldeinformationen

Das AWS SDK für Delphi sucht in einer bestimmten Reihenfolge nach Anmeldeinformationen und verwendet den ersten verfügbaren Satz für die aktuelle Anwendung.

Anmeldeinformationen Suchreihenfolge

Anmeldeinformationen, die ausdrücklich auf den AWS -Service -Client festgelegt sind, wie in der Übergabe von Zugriffs- und Geheimschlüssel direkt an den Kunden beschrieben.
Ein Anmeldeinformationen Profil mit dem Namen, der in TAWSConfigs.AWSProfileName nach einem Wert angegeben ist.
Ein Anmeldeinformationen mit dem von der AWS_PROFILE -Umgebungsvariablen angegebenen Namen.
Das Profil der [Standard] -Anmeldeinformationen.

Profilauflösung

Die Eigenschaft TAWSConfigs.AWSProfilesLocation steuert, wie der AWS SDK für Delphi Anmeldeinformationen findet. Wenn es leer ist, durchsucht es die Shared AWS -Anmeldeinformationen im Standardort. Wenn das Profil nicht vorhanden ist, suchen Sie ~/.aws/config (Linux oder macOS) oder %USERPROFILE%.awsconfig (Windows). Wenn TAWSConfigs.AWSProfilesLocation den Pfad zu einer Datei im Dateiformat AWS -Anmeldeinformationen enthält, sucht die SDK nur in der angegebenen Datei nach einem Profil mit dem angegebenen Namen nach Anmeldeinformationen.

Weitere Informationen zu Anmeldeinformationen Dateieinstellungen und benannten Profilen finden Sie in der AWS -Dokumentation.

Übergeben Sie Zugangs- und Geheimschlüssel direkt an den Kunden

Sie können einfach die Zugriffsschlüssel -ID und den geheimen Schlüssel direkt im Client -Konstruktor übergeben:

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

Die Verwendung von Anmeldeinformationen wird jedoch empfohlen, da es einfacher zu verwalten ist und auch mit der AWS -Befehlszeilenschnittstelle kompatibel ist.

Tests

Wichtig: Führen Sie die Integrationstests nicht auf einem Produktionskonto durch.

Integrationstests finden Sie im Awstests -Projekt. Diese Tests gehen davon aus, dass ein Standardprofil für Anmeldeinformationen konfiguriert wurde. Sie können Anmeldeinformationen mit Konfigurationsdateien, benannten Profilen oder Umgebungsvariablen einrichten.

Die Tests sind so konzipiert, dass die für die Prüfung erforderlichen Ressourcen erstellt und gelöscht werden. Es ist jedoch wichtig, Ihre Daten sicher zu halten. Führen Sie diese Tests nicht auf Konten aus, die Produktionsdaten oder Ressourcen enthalten. Da AWS -Ressourcen während des Durchführung dieser Tests erstellt und gelöscht werden, können Gebühren auftreten. Um die Gebühren zu verringern, indem die Tests durchgeführt wurden, konzentrieren sich die Tests auf AWS -Ressourcen mit minimalen Kosten.