How to set endpoint in apigatewaymanager

[jquesada2016]

I am trying to post to a connection on apigatewaymanagement, but cannot for the life of me, figure out how to correctly set the endpoint. I am calling the function from a lambda context using the lambda_runtime.

let client = Client::from_env();

client
    .post_to_connection()
    .set_connection_id(Some(connection_id))
    .set_data(Some(gwm::Blob::new(to_string(&e["body"])?)))
    .send()
    .await
    .expect("Failed to post to connection");

This one I never expected to work since it wouldn't be able to guess the endpoint's id or stage, though could figure out the region and callback schema.

The next thing I tried was the following:

let client = Client::from_conf(
    Config::builder()
        .endpoint_resolver(Endpoint::immutable(http::Uri::from_str(
            std::env::var("API_GW_ENDPOINT")
                .expect("API_GW_ENDPOINT not found")
                .as_str(),
        )?))
        .build(),
);

client
    .post_to_connection()
    .set_connection_id(Some(connection_id))
    .set_data(Some(gwm::Blob::new(to_string(&e["body"])?)))
    .send()
    .await
    .expect("Failed to post to connection");

Note, in the above code, the API_GW_ENDPOINT is an environment var set to https://apiidgoeshere123.execute-api.us-east-1.amazonaws.com/dev.

Any help at all would be much appreciated!

Edit

I did not provide the error output because it was just showing some opaque Error in the error message. I don't know what changed, but now it gave me a full explanation of the error, stating that the expected signature doesn't match. I am not sure in this case how to resolve it, as it should be properly pulling credentials from the env variables, since all other AWS lambdas are working fine.

[jmklix]

Have you taken a look at the AWS docs here?

[jquesada2016]

I did, but my question is more on the lines of how to actually do this correctly with this SDK. i.e. if I could get an example on how to configure the endpoint to send a request to a WebSocket connected client on API GW.

I understand how to do it through NodeJS, but not sure how to do it with this SDK beyond what i tried above. Running in lambda_runtime, in lambda.

[rcoh]

Sorry for the delay, we have an example here: https://github.com/awslabs/aws-sdk-rust/blob/main/examples/apigatewaymanagement/src/bin/post_to_connection.rs

[ymwjbxxq]

Hi @rcoh,

The example is excellent, and it works like a charm.

I would like to ask you if there is a way to initiate the Client inside the main to leverage the Lambda execution environment and not inside the handler.

Currently:

#[tokio::main]
async fn main() -> Result<(), Error> {
  // Initialize AWS client
 let aws_client = Init();

  lambda_runtime::run(handler_fn(|event: myCustomRequest, ctx: Context| {
    execute(&aws_client, event, ctx)
  }))
  .await?;
  Ok(())
}

pub async fn execute(aws_client: &AWSClient, event: myCustomRequest, _ctx: Context) -> Result<(), ApplicationError> {
 let endpoint = Endpoint::immutable(event.detail.endpoint.parse().unwrap());
  let config = aws_config::load_from_env().await;
  let api_management_config = config::Builder::from(&config)
      .endpoint_resolver(endpoint)
      .build();

  Client::from_conf(api_management_config)
      .post_to_connection()
      .connection_id(event.detail.connection_id)
      .data(Blob::new(presigned_url.as_bytes()))
      .send()
      .await?;
  Ok(())
}

I wish to do this:

• init the aws_sdk_apigatewaymanagement in the lambda context
• set the endpoint before posting

pub async fn execute(aws_client: &AWSClient, event: myCustomRequest, _ctx: Context) -> Result<(), ApplicationError> {
 let endpoint = Endpoint::immutable(event.detail.endpoint.parse().unwrap());

  aws_client
      .set_endpint(endpoint)
      .post_to_connection()
      .connection_id(event.detail.connection_id)
      .data(Blob::new(presigned_url.as_bytes()))
      .send()
      .await?;
  Ok(())
}

I also checked the other languages, and they are doing the same, but I wonder if there is an impact of performances doing Client::from_conf(api_management_config) inside the handler.

By the way, Inside the library I found:
// TODO(docs): include an example of using a static endpoint
/// Sets the endpoint resolver to use when making requests.
pub fn endpoint_resolver

If you can point out the example at some point would be great.

Thanks for the immense work.

[jdisanti]

In your first code snippet, you could optimize it a little bit by moving aws_config::load_from_env() call into main. You should only need to do this once on Lambda startup.

I experimented with the cost of instantiating a new client with a different endpoint each time, and on my machine, it came out to about 3.3 milliseconds per instantiation in a release build (averaged over 10,000 instantiations). I speculate that the bulk of the cost is initializing the underlying hyper client.

Depending on your use-case, you might be able to implement your own ResolveAwsEndpoint trait and feed that implementation to the config (which would allow you to create the client in main). The Endpoint::immutable, for example, implements this. However, if you need to handle any arbitrary endpoint from the Lambda event, then this won't work well for you.

What is your use-case here? Is it to use any arbitrary endpoint based on the Lambda event? Or do you have a known set of endpoints based on region, and the event has an endpoint for that region?

Thanks!

[ymwjbxxq]

First of all, thanks for the explanation.
I have no use case, I just wrote an example in Rust, and I am constantly comparing it with other languages.
My implementation is here, and the endpoint is not arbitrary.

[github-actions[bot]]

Hello! Reopening this discussion to make it searchable.