Descargar aws sdk delphi - Descargar el código fuente de aws sdk delphi

AWS SDK para Delphi

El AWS SDK para Delphi permite a los desarrolladores de Delphi trabajar fácilmente con los servicios web de Amazon y crear soluciones escalables con Amazon SES, Amazon SQS y más. Es un SDK no oficial basado en el AWS SDK oficial para .NET. Los proyectos de muestra se pueden encontrar en AWS SDK para el repositorio de muestras de Delphi.

Servicios compatibles

Esta es la lista de servicios de AWS actualmente respaldados por el SDK. Se agregarán más con el tiempo:

Amazon Lex: IA conversacional para chatbox
Amazon Polly: texto al habla
Amazon Rekognition: análisis de imágenes y videos
Amazon S3: servicio de almacenamiento simple
Amazon SES: API de servicio de correo electrónico simple (clásico)
Amazon SES V2: Servicio de correo electrónico simple API V2
Amazon SNS: servicio de notificación simple
Amazon SQS: servicio simple de cola
Traducción de Amazon: traducción de texto

Solicitudes de informe de errores y funciones

Utilice la página de problemas de GitHub para informar problemas o características de solicitud.

Versiones y plataformas de Delphi compatibles

AWS SDK para Delphi admite todas las versiones recientes de Delphi desde Delphi 10.3 Rio (es decir, Delphi 10.4 Sydney, Delphi 11, Delphi 12, etc.) y admite todas las plataformas disponibles en esas versiones de Delphi: Windows, Linux, Android, iOS y MacOS.

Bibliotecas requeridas

AWS SDK para Delphi no requiere ninguna biblioteca de terceros, está escrita en código Delphi 100% nativo y funciona en todos los SKU de las versiones de Delphi compatibles.

Instalación

Puede instalar la biblioteca realizando una instalación de Manuall.

Instalación manual

Para cada plataforma diferente, desea instalar el SDK:

Abra AWSPackages.groupproj Project Group en su Delphi IDE.
Agregue la carpeta de salida de la plataforma a la ruta de la biblioteca de la plataforma Delphi. Por ejemplo, si está construyendo para Delphi 12, Win32, agregue la carpeta <sdk_folder>/packages/d12/Win32/Release a la ruta de la biblioteca Delphi 12, Win32.
Cree todos los paquetes para la plataforma que desea instalar, en modo de lanzamiento.

Usando el SDK

Cada servicio web de Amazon tiene su propio paquete y esquema de nombres de la unidad, que es AWS<service>.dproj y AWS.<service>.*.pas , respectivamente. Por ejemplo, para Amazon SQS (servicio de cola simple), el nombre del paquete es AWSSQS.dproj y el nombre de la unidad es AWS.SQS.pas (y todas las otras unidades en el paquete siguen el mismo patrón, como AWS.SQS.Client.pas o AWS.SQS.ClientIntf.pas .

La mayoría de los tipos que necesita estarán en la unidad principal, lo que, por ejemplo, es AWS.SQS . Entonces, esa es la única unidad que necesitará para usar la mayoría de las funciones. Desde allí, puede acceder a todas las operaciones API disponibles. Cada método de operación recibe una interfaz de solicitud y devuelve una interfaz de respuesta.

En resumen, este es el proceso para realizar solicitudes de API:

Use la unidad principal del servicio, por ejemplo, AWS.SQS ;
Instanciar la interfaz del cliente ( TAmazonSQSClient );
Crear y completar la solicitud;
Método de operación de llamadas que pasa la solicitud para recibir la respuesta;
Procesar la respuesta.

Los siguientes ejemplos reciben un mensaje de una cola SQS y emiten la identificación y el cuerpo de cada mensaje recibido:

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

El siguiente ejemplo envía un correo electrónico a la dirección especificada utilizando el sujeto y el mensaje 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 ;

En todos los objetos de solicitud, las listas y diccionarios ya están instanciados, mientras que otros objetos asociados no lo están. No necesita destruir ninguna interfaz u objeto pasada o recibida de las operaciones, ni agregar a las solicitudes. Algunas operaciones tienen métodos sobrecargados que reciben menos parámetros sin procesar en lugar del objeto de solicitud completa, para un uso más simple.

Para obtener más información sobre las operaciones disponibles, consulte la documentación API del servicio de Amazon que está intentando usar. O, por supuesto, use la finalización del código Delphi para encontrar todos los métodos disponibles en cada cliente de servicio.

Ejemplos para servicios específicos

Amazon SNS

Puede usar completamente el servicio de notificación de Amazon: simple de AWS SDK para Delphi. La unidad principal es AWS.SNS . Encuentra información más detallada en este artículo sobre el uso de Amazon SNS con AWS SDK para Delphi, y por supuesto, puede consultar la referencia de la API de Amazon SNS.

Creando el cliente:

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

Obtenga ARN para todos los temas 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 ;

Cree un tema, obtenga su ARN, establezca/obtenga sus atributos y elimine el tema:

 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 ;

Suscribir un tema a una cola SQS a través de URL de cola, agregando los permisos adecuados:

 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 ;

Suscribir un tema para enviar un correo electrónico y devolver la suscripción 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 ;

Publicar un mensaje a un tema:

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

Eliminar una suscripción:

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

Analice un mensaje SNS de JSON y valida la firma:

 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 ;

Envíe un mensaje SMS a un número de teléfono:

 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 ;

Cartas credenciales

El AWS SDK para Delphi busca credenciales en cierto orden y utiliza el primer conjunto disponible para la aplicación actual.

Orden de búsqueda de credenciales

Credenciales que se establecen explícitamente en el cliente de servicio AWS, como se describe al pasar el acceso y las claves secretas directamente al cliente.
Un perfil de credenciales con el nombre especificado por un valor en TAWSConfigs.AWSProfileName .
Un perfil de credenciales con el nombre especificado por la variable de entorno AWS_PROFILE .
El perfil de credenciales [predeterminados].

Resolución de perfil

La propiedad de TAWSConfigs.AWSProfilesLocation controla cómo el AWS SDK para Delphi encuentra perfiles de credenciales. Si está vacío, busca el archivo de credenciales de AWS compartido en la ubicación predeterminada. Si el perfil no está allí, busque ~/.aws/config (Linux o macOS) o %USERPROFILE%.awsconfig (Windows). Si TAWSConfigs.AWSProfilesLocation contiene la ruta a un archivo en el formato de archivo de credenciales de AWS, entonces el SDK busca credenciales solo en el archivo especificado para un perfil con el nombre especificado.

Consulte la documentación de AWS para obtener más información sobre la configuración del archivo de credenciales y los perfiles nombrados.

Pasar acceso y claves secretas directamente al cliente

Simplemente puede pasar el ID de clave de acceso y la clave secreta directamente en el constructor del cliente:

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

Aunque se recomienda usar el perfil de credenciales, ya que es más fácil de administrar y también es compatible con la interfaz de línea de comandos AWS.

Pruebas

IMPORTANTE: No ejecute las pruebas de integración en una cuenta de producción.

Las pruebas de integración se pueden encontrar en el proyecto AWSTESTS . Estas pruebas suponen que se ha configurado un perfil predeterminado para credenciales. Puede configurar credenciales utilizando archivos de configuración, perfiles con nombre o variables de entorno.

Las pruebas están diseñadas para crear y eliminar los recursos necesarios para las pruebas, pero es importante mantener sus datos seguros. No ejecute estas pruebas en cuentas que contienen datos o recursos de producción. Dado que los recursos de AWS se crean y eliminan durante la ejecución de estas pruebas, pueden ocurrir cargos. Para reducir los cargos ocurridos, ejecutando las pruebas, se centran en los recursos de AWS que tienen un costo mínimo.