download do aws sdk delphi - aws sdk delphi Download de código fonte

AWS SDK para Delphi

O AWS SDK da Delphi permite que os desenvolvedores da Delphi trabalhem facilmente com os serviços da Web da Amazon e criem soluções escaláveis com a Amazon SES, o Amazon SQS e muito mais. É um SDK não oficial baseado no SDK oficial da AWS para .NET. Projetos de amostra podem ser encontrados no AWS SDK para repositório de amostras Delphi.

Serviços suportados

Esta é a lista de serviços da AWS atualmente suportados pelo SDK. Mais será adicionado ao longo do tempo:

Amazon Lex: AI conversacional para chatbox
Amazon Polly: texto para fala
Amazon Rekognition: Análise de imagem e vídeo
Amazon S3: serviço de armazenamento simples
Amazon SES: API simples de serviço de email (clássico)
Amazon SES V2: API de serviço de email simples v2
Amazon SNS: Serviço de notificação simples
Amazon Sqs: serviço de fila simples
Amazon traduz: tradução de texto

Relatório de bugs e solicitações de recursos

Use a página de problemas do GitHub para relatar problemas ou solicitar recursos.

Versões e plataformas suportadas Delphi

O AWS SDK for Delphi suporta todas as versões recentes do Delphi desde o Delphi 10.3 Rio (ou seja, Delphi 10.4 Sydney, Delphi 11, Delphi 12, etc.) e suporta todas as plataformas disponíveis nessas versões Delphi: Windows, Linux, Android, iOS e MacOs.

Bibliotecas necessárias

O AWS SDK para Delphi não requer nenhuma biblioteca de terceiros, é escrita em código Delphi 100% nativo e funciona em todos os SKUs de versões Delphi suportadas.

Instalação

Você pode instalar a biblioteca executando uma instalação Manuall.

Instalação manual

Para cada plataforma diferente, você deseja instalar o SDK:

Open AWSPackages.groupproj Grupo de projetos no seu Delphi IDE.
Adicione a pasta de saída da plataforma ao caminho da biblioteca da plataforma Delphi. Por exemplo, se você estiver construindo para Delphi 12, Win32, adicione a pasta <sdk_folder>/packages/d12/Win32/Release ao caminho da biblioteca Delphi 12, Win32.
Crie todos os pacotes para a plataforma que você deseja instalar, no modo de liberação.

Usando o SDK

Cada serviço da Web da Amazon possui seu próprio esquema de nomes de pacote e unidade, que é AWS<service>.dproj e AWS.<service>.*.pas Por exemplo, para o Amazon Sqs (serviço simples de fila), o nome do pacote é AWSSQS.dproj e o nome da unidade é AWS.SQS.pas (e todas as outras unidades do pacote seguem o mesmo padrão, como AWS.SQS.Client.pas ou AWS.SQS.ClientIntf.pas .

A maioria dos tipos que você precisa estará na unidade principal, que, por exemplo, é AWS.SQS . Portanto, essa é a única unidade que você precisará usar a maioria das funções. A partir daí, você pode acessar todas as operações de API disponíveis. Cada método de operação recebe uma interface de solicitação e retorna uma interface de resposta.

Em resumo, este é o processo para executar solicitações de API:

Use a unidade principal do serviço, por exemplo, AWS.SQS ;
Instanciar a interface do cliente ( TAmazonSQSClient );
Criar e preencher a solicitação;
Método de operação de chamada, passando a solicitação para receber a resposta;
Processar a resposta.

Os exemplos a seguir recebem uma mensagem de uma fila SQS e produzem o ID e o corpo de cada mensagem recebida:

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

O exemplo a seguir envia um e-mail para o endereço especificado usando o assunto e a mensagem especificados:

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

Em todos os objetos de solicitação, listas e dicionários já estão instantados, enquanto outros objetos associados não são. Você não precisa destruir nenhuma interface ou objeto passado ou recebido das operações ou adicionado às solicitações. Algumas operações têm métodos sobrecarregados que recebem menos parâmetros brutos em vez do objeto de solicitação completa, para uso mais simples.

Para obter mais informações sobre as operações disponíveis, consulte a documentação da API do serviço Amazon que você está tentando usar. Ou, é claro, use a conclusão do código Delphi para encontrar todos os métodos disponíveis em cada cliente de serviço.

Exemplos para serviços específicos

Amazon SNS

Você pode usar totalmente o Amazon SNS: Serviço de notificação simples do AWS SDK para Delphi. A unidade principal é AWS.SNS . Você encontra informações mais detalhadas neste artigo sobre o uso do Amazon SNS com o AWS SDK para Delphi e, é claro, você pode se referir à própria API da Amazon SNS.

Criando o cliente:

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

Obtenha ARN para todos os tópicos existentes:

 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 ;

Crie um tópico, obtenha seu ARN, defina/obtenha seus atributos e exclua tópico:

 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 ;

Inscreva -se um tópico em uma fila SQS via URL da fila, adicionando as permissões adequadas:

 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 ;

Inscreva-se um tópico para e-mail e devolva a assinatura 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 ;

Publique uma mensagem para um tópico:

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

Exclua uma assinatura:

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

Analisar uma mensagem SNS da JSON e validar a assinatura:

 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 ;

Envie uma mensagem SMS para um número de telefone:

 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 ;

Credenciais

O AWS SDK for Delphi procura credenciais em um determinado pedido e usa o primeiro conjunto disponível para o aplicativo atual.

Ordem de pesquisa de credenciais

Credenciais que são explicitamente definidas no cliente de serviço da AWS, conforme descrito na passagem de acesso e teclas secretas diretamente ao cliente.
Um perfil de credenciais com o nome especificado por um valor em TAWSConfigs.AWSProfileName .
Um perfil de credenciais com o nome especificado pela variável de ambiente AWS_PROFILE .
O perfil de credenciais [padrão].

Resolução do perfil

A propriedade TAWSConfigs.AWSProfilesLocation controla como o AWS SDK para Delphi encontra perfis de credenciais. Se estiver vazio, pesquisa o arquivo de credenciais compartilhados da AWS no local padrão. Se o perfil não estiver lá, pesquise ~/.aws/config (linux ou macOS) ou %USERPROFILE%.awsconfig (windows). Se TAWSConfigs.AWSProfilesLocation contiver o caminho para um arquivo no formato do arquivo de credenciais da AWS, o SDK busca credenciais apenas no arquivo especificado para um perfil com o nome especificado.

Consulte a documentação da AWS para obter mais informações sobre as configurações de arquivos de credenciais e perfis nomeados.

Passando o acesso e as chaves secretas diretamente para o cliente

Você pode simplesmente passar a chave de acesso e a chave secreta diretamente no construtor do cliente:

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

Embora o uso do perfil de credenciais seja recomendado, pois é mais fácil de gerenciar e também compatível com a interface da linha de comando da AWS.

Testes

IMPORTANTE: Não execute os testes de integração em uma conta de produção.

Testes de integração podem ser encontrados no projeto Awards . Esses testes assumem que um perfil padrão foi configurado para credenciais. Você pode configurar credenciais usando arquivos de configuração, perfis nomeados ou variáveis de ambiente.

Os testes foram projetados para criar e excluir os recursos necessários para o teste, mas é importante manter seus dados seguros. Não execute esses testes em contas que contenham dados ou recursos de produção. Como os recursos da AWS são criados e excluídos durante o funcionamento desses testes, podem ocorrer cargas. Para reduzir as cobranças, a execução dos testes se concentra nos recursos da AWS com custo mínimo.