A modern programming language that makes developers happier.

kotlinlang

set the channel description: Channel for discussion of AWS SDK and Smithy for Kotlin

Hey, by any chance does anyone have a implementation of ByteStream.ChannelStream() that works for input stream?

I tried to switch from the java sdk to kotlin sdk for s3 recently and hit a wall. With the java sdk, I pass an input stream to a putObject or uploadPart request, but there doesn't seem to be an equivalent right now in the kotlin sdk. I saw an issue, that converts from ByteStream to InputStream, but not the other way. Happy to file an issue for it if it's not on the roadmap already, but curious if anyone has a good implementation in the meantime.

Hey Todd, there's not yet a built-in SDK function to wrap an `InputStream` as a `ByteStream` but that's a great <https://github.com/awslabs/aws-sdk-kotlin/issues/new?assignees=&amp;labels=feature-request%2Cneeds-triage&amp;projects=&amp;template=feature_request.yml&amp;title=%28short+issue+description%29|feature to request>. :slightly_smiling_face:

In the meantime, you may be able to come up with your own solution by subclassing <https://github.com/smithy-lang/smithy-kotlin/blob/f22e4bd5a22903c5da7f4621fc730c2c9164b239/runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/content/ByteStream.kt#L44-L70|ChannelStream/SourceStream> or by reading from your `InputStream`, emitting chunks as a `Flow&lt;ByteArray&gt;`, and then using &lt;<https://github.com/smithy-lang/smithy-kotlin/blob/f22e4bd5a22903c5da7f4621fc730c2c9164b239/runtime/runtime-core/common/src/aws/smithy/kotlin/runtime/content/ByteStream.kt#L134-L166%7CFlow&lt;ByteArray&gt;.toByteStream(...)>&gt;.

Thanks Ian. I just filed a feature request: <https://github.com/awslabs/aws-sdk-kotlin/issues/1352>

And I'll take a shot at some of your suggestions in the meantime.

Hello again, Todd. Version <https://github.com/awslabs/aws-sdk-kotlin/releases/tag/v1.2.52|1.2.52> of the SDK was released today and includes new extension methods to convert `InputStream` to `ByteStream`!

Wow that was extremely fast! Thanks Ian! I'll try it out

Screenshot 2024-07-16 at 3.57.29 AM.png

Screenshot 2024-07-16 at 3.32.51 AM.png

I am trying to invoke this function through aws lambda, how should i write a handler for this since there is no class involved

If you use one of the Java runtimes for AWS Lambda (e.g., Java 21) then you must <https://docs.aws.amazon.com/lambda/latest/dg/java-handler.html|design your function handler as an instance method in a class>. For example:

```package org.mimar

class MimarLambdaHandler {
    fun handleRequest(input: Map&lt;String, String&gt;): Map&lt;String, String&gt; {
        println("MimarLambdaHandler invoked with input $input")
        return mapOf("resultCode", "success")
    }
}```
You would then set the Lambda Function's handler to be `org.mimar.MimarLambdaHandler::handleRequest`.

I showed using maps for receiving/sending data but there are an <https://docs.aws.amazon.com/lambda/latest/dg/java-handler.html#java-handler-types|assortment of acceptable input/output types the Java runtime recognizes>. There's also <https://docs.aws.amazon.com/lambda/latest/dg/java-handler.html#java-handler-interfaces|a JVM-specific handler interface library> which allows you to implement an interface and provides access to convenience wrappers for things like context and logging.

It's probably _possible_ to write Lambda handlers with top-level Kotlin functions like a `main` method but I'm not exactly sure how you'd do it with the Java runtime. :thinking_face: Moreover, that gives you no ability to reuse state between Lambda invocations on the same instance, which are typically modeled as class-level fields. For instance:

```class FooLambdaHandler {
    val xyzClient by lazy {
        // This is expensive so do it lazily and reuse it throughout the class lifecycle
        XyzClient()
    }

    fun handleRequest(...) {
        xyzClient.invokeOperation(...)
    }
}```
Because the client is owned by the class and class instances are reused by subsequent Lambda invocations on already-running instances, you don't have to pay the cost of initialization every time—just the when a new instance is started.

interesting <@U044DCH1YCQ>  I will try these,one more question though i want to use graalvm instead of java21 can show a resource where i can look into it?

Unfortunately I haven't played much with GraalVM so I don't have any trusted resources to share. :face_with_diagonal_mouth: I do see a few hits on Google so I'd guess other people have had success with it. I need to spend some time to play around with it myself!

The SDK was recently updated to add <https://github.com/awslabs/aws-sdk-kotlin/blob/main/docs/targets.md#graalvm|support for GraalVM> so at least you should be able to use that once you get your project bootstrapped.

<@U044DCH1YCQ> what you showed in your talk at kotlinconf last year had only a main function and same is in the examples, how do we configure that with java runtime or i have to use something else??
i am very new backend and aws

Yeah, my intro talks don't cover much in the way of configuration. :sweat_smile:

Can you clarify your question a little bit? I'm unsure what you mean by "how do we configure that with java runtime"?

so i am assuming kotlin-js  is not supported as i tried to add aws sdk to an app with js main so cant use nodejs + kotlin js. Now, the question is i dont want to use the java way of creating lambda which is by using classes i want to use only the main function

`fun main(){//lambda code here}`
and make it accessible on aws console instead of getting no class found excception

one more thing when we build a jar and upload it to aws, internally the code is like this

```  package com.kotlin.lambda;

import kotlin.Metadata;
import kotlin.Unit;
import kotlin.coroutines.Continuation;
import kotlin.coroutines.jvm.internal.RunSuspendKt;
import kotlin.jvm.functions.Function1;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;


public final class CreateFunctionKt {
   @Nullable
   public static final Object main(@NotNull String[] args, @NotNull Continuation<? super Unit> $completion) {
      String usage = "\n    Usage: \n        <functionName> <s3BucketName> <s3Key> <role> <handler> \n\n    Where:\n        functionName - The name of the Lambda function. \n        s3BucketName - The Amazon Simple Storage Service (Amazon S3) bucket name that stores the JAR file for the Lambda function. \n        s3Key - The key name of the JAR file.\n        role - The role ARN that has Lambda permissions. \n        handler - The fully qualified method name (for example, example.Handler::handleRequest).  \n    ";
      System.out.println("dishkum tait");
      return Unit.INSTANCE;
   }

   // $FF: synthetic method
   public static void main(String[] args) {
      RunSuspendKt.runSuspend((Function1)(new Function1<Object>(args) {
         // $FF: synthetic field
         private String[] args;

         @Nullable
         public final Object invoke(@NotNull Continuation<Object> $completion) {
            return CreateFunctionKt.main(this.args, $completion);
         }

         {
            Intrinsics.checkNotNullParameter(args, "args");
            this.args = args;
         }
      }));
   }
}
    ```
So shouldnt the main function be accessible in console like this com.kotlin.lambda.CreateFynctionKt::main?

&gt; so i am assuming kotlin-js is not supported
That's correct, only Kotlin/JVM is available right now. We're working on adding Kotlin/Native support and we have <https://github.com/awslabs/aws-sdk-kotlin/issues/228|a backlog item for Kotlin/JS> that you could upvote if you like.

&gt; i dont want to use the java way of creating lambda which is by using classes i want to use only the main function
May I ask why? I understand that it's slightly more code but it should achieve the same result unless there's some other requirements you have that can _only_ be met by a `main` method.

&gt; shouldnt the main function be accessible in console like this com.kotlin.lambda.CreateFynctionKt::main
Oh possibly, I've never tried it that way. As far as I understand, the Java runtime for AWS Lambda requires an _instance method_ (vs a _static method_) but you could certainly test that out!

ok so answering the second point RequestHandler is not in aws kotlin sdk

You're correct, `RequestHandler` isn't in any of the SDKs, it comes from the *<https://central.sonatype.com/artifact/com.amazonaws/aws-lambda-java-core|com.amazonaws:aws-lambda-java-core>* package. Fortunately, implementing it is not required, merely helpful. Instead you simply write _any_ class containing a method with _any_ name as long as it has <https://docs.aws.amazon.com/lambda/latest/dg/java-handler.html#java-handler-types|the input/output types listed in the Java handler documentation>.

ok, so this works for input like map but if i add string as parameter it requires a context which again isnt part of the sdk

now i get it why it wasnt working last night

<@U044DCH1YCQ> I've discovered that I can actually use the method I described earlier. After generating the uber jar, the function is wrapped inside a class called `com.kotlin.lambda.CreateFunctionKt`. Now, I can write the handler as `com.kotlin.lambda.CreateFunctionKt::handleRequest`.
The issue arises with the parameters. Some of them, like strings, require context to br passed to function. I was attempting to use a function with this signature:
```fun handleRequest(input: Map<String, String>): Map<String, String> {```
Using this function signature works perfectly fine, so there's no need to wrap it in a class. However, I'm still curious about why the context parameter is necessary. Could it be a bug? Should I create an issue on GitHub about this?

Trying to reproduce this myself... :loading:

...sorry, that took a bit longer than expected. I'm able to write a handler that accepts a string and it seems to run successfully:

```class IOTypeTestHandler {
    fun handle(input: String): String {
        println("Got string $input")
        return "Result!"
    }
}```

What does your handler method look like? What kind of error are you getting?

ok so I am not using class i am using only the main function as described in the sample

```suspend fun main(args: Array<String>) {
    val usage = """
    Usage: 
        <functionName> <s3BucketName> <s3Key> <role> <handler> 

    Where:
        functionName - The name of the Lambda function. 
        s3BucketName - The Amazon Simple Storage Service (Amazon S3) bucket name that stores the JAR file for the Lambda function. 
        s3Key - The key name of the JAR file.
        role - The role ARN that has Lambda permissions. 
        handler - The fully qualified method name (for example, example.Handler::handleRequest).  
    """

    println("Lambda invoked")
}```
when i do this it doesnt work and i get this exception

```Ignoring two-argument overload because second parameter type is not Context
START RequestId: 3a651f92-43d6-4f7f-a9ac-d2c8fe7e5eff Version: $LATEST
An error occurred during JSON parsing: java.lang.RuntimeException
java.lang.RuntimeException: An error occurred during JSON parsing
Caused by: java.io.UncheckedIOException: com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize value of type `[Ljava.lang.String;` from Object value (token `JsonToken.START_OBJECT`)
 at [Source: (ByteArrayInputStream); line: 1, column: 1]
	at com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory$InternalSerializer.fromJson(JacksonFactory.java:176)
Caused by: com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize value of type `[Ljava.lang.String;` from Object value (token `JsonToken.START_OBJECT`)
 at [Source: (ByteArrayInputStream); line: 1, column: 1]
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.exc.MismatchedInputException.from(MismatchedInputException.java:59)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.DeserializationContext.reportInputMismatch(DeserializationContext.java:1746)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.DeserializationContext.handleUnexpectedToken(DeserializationContext.java:1520)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.DeserializationContext.handleUnexpectedToken(DeserializationContext.java:1425)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.DeserializationContext.extractScalarFromObject(DeserializationContext.java:937)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.deser.std.StdDeserializer._parseString(StdDeserializer.java:1421)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.deser.std.StringArrayDeserializer.handleNonArray(StringArrayDeserializer.java:338)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.deser.std.StringArrayDeserializer.deserialize(StringArrayDeserializer.java:143)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.deser.std.StringArrayDeserializer.deserialize(StringArrayDeserializer.java:27)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.readRootValue(DefaultDeserializationContext.java:323)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.ObjectReader._bindAndClose(ObjectReader.java:2105)
	at com.amazonaws.lambda.thirdparty.com.fasterxml.jackson.databind.ObjectReader.readValue(ObjectReader.java:1481)
	at com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory$InternalSerializer.fromJson(JacksonFactory.java:174)

END RequestId: 3a651f92-43d6-4f7f-a9ac-d2c8fe7e5eff
REPORT RequestId: 3a651f92-43d6-4f7f-a9ac-d2c8fe7e5eff	Duration: 868.93 ms	Billed Duration: 869 ms	Memory Size: 128 MB	Max Memory Used: 103 MB	Init Duration: 395.54 ```

However this works fine
```fun handleRequest(input: Map&lt;String, String&gt;): Map&lt;String, String&gt; {
 }```
reason for not using a class is that it has its use cases but for this simple usecase as a class is already generated upon building jar i.e CreateFunctionKt i can use that instead of creating a class write the handler like this on console `com.kotlin.lambda.CreateFunctionKt::handleRequest`

A ha! I think I understand now. :bulb:

This error turns out to be the clue:
```Ignoring two-argument overload because second parameter type is not Context```
Your function `suspend fun main(args: Array<String>)` actually has _two_ parameters once it's compiled to JVM byte code because `suspend` <https://www.droidcon.com/2024/04/25/how-suspend-functions-work-in-kotlin-under-the-hood/#c148|adds a continuation parameter>. The Lambda Java runtime, when it looks for your handler method via reflection, finds this method signature:
```public final class foo.bar.ClassNameKt {
  public static final java.lang.Object main(java.lang.String[], kotlin.coroutines.Continuation<? super kotlin.Unit>);
}```
The Lambda runtime knows how to interact with many different input types but `Continuation` isn't one of them. You should be able to get it working by removing `suspend` and adding `runBlocking` inside the function:
```fun main(args: Array<String>) {
    runBlocking {
        println("Lambda invoked")
    }
}```
Technically `runBlocking` is only necessary around calls to `suspend` functions so you can narrow the scope of it if you wish. But I think we've successfully proven that a top-level `main` function _can work successfully_ as a Lambda function handler! :party-parrot:

One other note is that when your Lambda function handler's input is an array or collection type, the invocation payload must be in the form of a JSON array (e.g., `[ "arg1", "arg2", "arg3" ]`).

hmm it makes sense, i havent tried it yet but i still dont think thats the cause, i might be wrong but ill update after giving it a try.

ok so i tried with this function signature `fun handleRequest(string: String) {}`  and i still got the same exception. As you mentioned it shoud be able to  take same arguments as a java handler which make <https://github.com/awsdocs/aws-lambda-developer-guide/blob/main/sample-apps/java-basic/src/main/java/example/HandlerString.java|string a valid argument for the lambda handle>r . I believe its asking for the same Context parameter that comes from `com.amazonaws.services.lambda.runtime.Context;`  which is not available in the kotlin sdk. But i am still confused why is it working for map and not string or array :face_holding_back_tears::awkward-monkey:

I might be wrong but event after byte code conversion it should ask for continuation not context according to this bytecode
`public final class CreateFunctionKt {` 
             `@NotNullpublic static final Object handleRequest(@NotNull String string, @NotNull Continuation&lt;? super Unit&gt; $completion) {` 
                   `System.out.println("dishkum tait");` 
                   `return Unit.INSTANCE;` 
              `}`
`}`

Yes, but the Lambda Java runtime tries to resolve the handler method at runtime via reflection. It does this by identifying potential method signatures it could use and examining the types of their parameters. The _only time_ the Java runtime will use a handler method with two parameters is when that second parameter is either `Context` or `OutputStream`. Any other method signature is unusable by the runtime because it has no idea what argument to pass. That's what the error message is trying to convey: `Ignoring two-argument overload because second parameter type is not Context` means "I found a method with two params, I was looking for that second param to be `Context` but it wasn't, so I can't use it".

When it was working with `Map`, was the function a `suspend` function?

i understand that but this is not a suspend function and it doesnot work  `fun handleRequest(string: String) {}`

The stack trace

`START RequestId: 3142e878-8f51-4d20-a1f0-681133a8975c Version: $LATEST An error occurred during JSON parsing: java.lang.RuntimeException java.lang.RuntimeException: An error occurred during JSON parsing Caused by: java.io.UncheckedIOException: <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize value of type java.lang.String from Object value (token JsonToken.START_OBJECT) at [Source: (ByteArrayInputStream); line: 1, column: 1] at com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory$InternalSerializer.fromJson(JacksonFactory.java:176) Caused by: <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize value of type java.lang.String from Object value (token JsonToken.START_OBJECT) at [Source: (ByteArrayInputStream); line: 1, column: 1] at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.exc.MismatchedInputException.from(MismatchedInputException.java:59) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.DeserializationContext.reportInputMismatch(DeserializationContext.java:1746) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.DeserializationContext.handleUnexpectedToken(DeserializationContext.java:1520) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.DeserializationContext.handleUnexpectedToken(DeserializationContext.java:1425) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.DeserializationContext.extractScalarFromObject(DeserializationContext.java:937) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.deser.std.StdDeserializer._parseString(StdDeserializer.java:1421) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.deser.std.StringDeserializer.deserialize(StringDeserializer.java:48) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.deser.std.StringDeserializer.deserialize(StringDeserializer.java:11) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.deser.DefaultDeserializationContext.readRootValue(DefaultDeserializationContext.java:323) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.ObjectReader._bindAndClose(ObjectReader.java:2105) at <http://com.amazonaws.lambda.thirdparty.com|com.amazonaws.lambda.thirdparty.com>.fasterxml.jackson.databind.ObjectReader.readValue(ObjectReader.java:1481) at com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory$InternalSerializer.fromJson(JacksonFactory.java:174) END RequestId: 3142e878-8f51-4d20-a1f0-681133a8975c REPORT RequestId: 3142e878-8f51-4d20-a1f0-681133a8975c	Duration: 22.41 ms	Billed Duration: 23 ms	Memory Size: 128 MB	Max Memory Used: 103 MB`

Oh yeah, when you're invoking a handler that accepts a `String` the payload has to be a JSON string, not a JSON object. The <https://docs.aws.amazon.com/lambda/latest/dg/java-handler.html#java-handler-types|Choosing input and output types> documentation clarifies the expected behavior a bit. But you'll have to invoke your function with a payload like `"this is my payload"` rather than a full JSON object.

oh now i get it thanks <@U044DCH1YCQ> for your time, Atleast now we know we can use a function with class. Thanks again

<@U044DCH1YCQ> i have set graalvm for kotlin sdk and native image is working fine. However, native image needs the main class to have main fucntion with signature `fun main(args: String[])`  because of javas static main method. Is there a way i can you my custom handler? any idea if anyone has

Hey Kashif, I was able to get a static *main* function to work as a Lambda handler in Kotlin:
```fun main(args: Array&lt;String&gt;) {
    runBlocking {
        println("Lambda invoked")
    }
}```
Note that it cannot be `suspend` and choosing `Array&lt;String&gt;` for the arguments means the Lambda payload must be a JSON array. I haven't tried this on GraalVM though—only vanilla JVM.

this works on both, graalVM and jvm. However, the issue i am having is different graal vm native image requires a main class for the application and the application must have main function with  this signature `fun main(args: Array<String>) {}`  . So, i am unable to use fun main(args: Map<String, String>): Map<String, String>

<https://github.com/Kashif-E/AWS-Lambda-Kotlin> theres a release in this repo that you can try with custom runtime on lambda this has a main function `fun main(args: Array&lt;String&gt;) {}`   but it quits unexpectedly

And what Lambda runtime are you using since the Java runtime doesn't support GraalVM?

i am using custom runtime its working fine the issue is while generating native image i cant use any function signature for main other than fun main(args:Array<String>) or else it throws error main function not found

If `fun main(args: Array&lt;String&gt;)` works fine in Lambda and that's what GraalVM requires then don't you have a working solution?

not exactly, i can pass a map or return anything:melting_face:

Then you might need to follow up with the maintainers of the custom runtime you're using. The traditional runtimes maintained by AWS assume that handlers will take the form of a method in a class because they intend to reuse already-running executions and avoid recalculating state. Using a `main` method is kind of antithetical to that pattern so maybe the maintainers of your custom runtime have better guidance to offer.

I am new to this stuff will dig deeper into it

Hey! I saw you opened a <https://github.com/awslabs/aws-sdk-kotlin/discussions/1371|GitHub discussion post too>. Can you share the specific exception you're getting?

Sorry i actually closed it was my fault but still i would tell that i tested on Emulator it did not work it worked on my device

I can't say for sure without more details, it could be caused by a number of things

Okk I'll send you the code and all in details basically I was trying it in a KMP project but got to know that iOS is still not supported only android and jvm right ?

Btw do you have any idea in how much time we can get IOS support like is it on the pipeline right now or scheduled for further future

btw i was getting
```2024-07-30 09:38:33.058 21330-21349 System.out              org.example.maconsole                I  Unexpected error: java.net.UnknownHostException: Unable to resolve host "ec2.eu-north-1.amazonaws.com": No address associated with hostname```

```import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider
import aws.sdk.kotlin.services.cognitoidentity.CognitoIdentityClient
import aws.sdk.kotlin.services.ec2.Ec2Client
import aws.sdk.kotlin.services.ec2.model.DescribeInstancesRequest
import aws.sdk.kotlin.services.ec2.model.Ec2Exception

object AwsConfig {
   

    private val cognitoIdentityClient = CognitoIdentityClient {
        region = REGION
    }


    suspend fun describeEC2Instances() {
        val credentials = StaticCredentialsProvider {
            accessKeyId = ACCESS_KEY_ID
            secretAccessKey = SECRET_ACCESS_KEY
        }
        try {
            Ec2Client {
                region = REGION
                credentialsProvider = credentials
            }.use { ec2 -&gt;
                val request = DescribeInstancesRequest {
                }
                val response = ec2.describeInstances(request)
                println(response)
                response.reservations?.forEach { reservation -&gt;
                    reservation.instances?.forEach { instance -&gt;
                        println("Ec2 Instance Id is ${instance.instanceId}")
                        println("Ec2 Image id is ${instance.imageId}")
                        println("Ec2 Instance type is ${instance.instanceType}")
                        println("Ec2 Instance state name is ${instance.state?.name}")
                        println("Ec2 Monitoring information is ${instance.monitoring?.state}")
                    }
                }
            }
        } catch (e: Ec2Exception) {
            println("Error describing EC2 instances: ${e.message}")
        } catch (e: Exception) {
            println("Unexpected error: ${e.message}")
        }


    }
}```
This is my class and i have added these dependencies
```    implementation("aws.sdk.kotlin:iam:1.0.0")
            implementation("aws.sdk.kotlin:cloudwatch:1.0.0")
            implementation("aws.sdk.kotlin:cognitoidentityprovider:1.0.0")
            implementation("aws.sdk.kotlin:ec2:1.0.0")

         //   implementation("aws.sdk.kotlin:auth-cognito:0.20.0-beta")
            implementation("aws.sdk.kotlin:cognitoidentity:1.0.0")```

&gt; Unable to resolve host "<http://ec2.eu-north-1.amazonaws.com|ec2.eu-north-1.amazonaws.com>": No address associated with hostname
Looks like a networking issue to me, you should confirm that the emulated device has internet connection / possibly misconfigured DNS

&gt; Btw do you have any idea in how much time we can get IOS support like is it on the pipeline right now or scheduled for further future
We are working on it right now, there's no estimated completion date, but you can track it here: <https://github.com/awslabs/aws-sdk-kotlin/issues/229>

<@U04DPQ33Z55> ya that was an issue from my Emulator like it was showing internet as connected but when i opened chrome in my emulator it was not working

that makes sense, glad we figured out the issue

btw do you know whcih SDK or lib i can use to see my costing of EC2 instance in the app

If you just want to know the hourly rate, you can check <https://aws.amazon.com/ec2/pricing/|the EC2 pricing page>. If you want a specific cost of your specific use, you will need to use something like <https://aws.amazon.com/aws-cost-management/aws-cost-explorer/|AWS Cost Explorer>, I can't help with that

no no i didnt mean that pricing the cost of the machine running its like like pay as you go that one i was talking actually

Sorry I don't know what you're trying to accomplish. I'd recommend reaching out to AWS support for any questions unrelated to the AWS SDK for Kotlin

Btw anyone has any idea i want to know the billing information of my EC2 instances any idea how i can get these from

image.png

Hey Bharat, most billing information is found in the AWS Console.
1. Click the top-right menu (usually has your account name and/or account ID)
2. Click the Billing and Cost Management item

There's several ways to view your costs in the Billing and Cost Management area. Cost Explorer is the one I use most often and lets you filter down by service (e.g., EC2).

<@U044DCH1YCQ> yes i understand that but is there any way to show that using an SDK or something in Android that my requirement actually

Oh my mistake. :sweat_smile: Yes, you can use the `CostExplorerClient` in the *aws.sdk.kotlin:costexplorer* package. I don't have any experience with this product as a web service (merely as a UI) so I can't necessarily advise you on which specific APIs to use. But hopefully the client method names and the <https://docs.aws.amazon.com/aws-cost-management/latest/APIReference/API_Operations_AWS_Cost_Explorer_Service.html|documentation for AWS Cost Explorer> can guide you!

<@U044DCH1YCQ> Awesome Thanks for the help :smile:

:mega: For all the DynamoDB enthusiasts out there, the <https://aws.amazon.com/blogs/developer/announcing-dev-preview-of-dynamodb-mapper-for-kotlin/|Developer Preview of DynamoDB Mapper for Kotlin is now available>! Check it out and let us know what you think in this channel or <https://github.com/awslabs/aws-sdk-kotlin|on GitHub>. :grin:

Hi all, when starting a new project with kotlin, should I go for the aws-sdk for java or aws-sdk for kotlin. In my perception the sdk for java might be more stable due to having to support a larger user base, but do correct me if I'm wrong. Thanks in advance

Both are equally supported in terms of stability and availability. Kotlin has a bit fewer features (no DynamoDB Mapper (it's in preview), S3 Transfer Manager) that we are still working to get feature parity on. But if you don't plan to use them, then the Kotlin SDK is much more idiomatic when writing Kotlin.

Also consider whether multiplatform support will be important for your project in the future. AWS is working on adding Kotlin/Native support to the SDK and more platforms will be added in the future. The AWS SDK for Java will likely _only_ ever work on JVM.

Hi all, my files are not fully being uploaded to digitalocean's spaces (s3 compatible).The image is accessible but not being fully rendered due to data lost, I didn't see any exception during the upload process while using the aws sdk for kotlin. Where can I start looking to see what caused the problem? Thanks in advance

I used `s3cmd` and it worked out fine, so probably the problem is at my sdk implementation.

here is the code snippet that I use to do the upload:

```val fileToSend = File("uploads/$fileName")
                            part.provider().copyAndClose(fileToSend.writeChannel())

                            val s3ObjectRequest = PutObjectRequest({
                                key = fileName
                                body = fileToSend.asByteStream()
                                contentType = "image/jpeg"
                            })

                            s3Client.putObject(s3ObjectRequest)```
Please let me know what can I change here, thanks in advance y'all

What is this line meant to do? `part.provider().copyAndClose(fileToSend.writeChannel())`

Overall your code looks correct. I'd recommend dumping the bytes of `fileToSend` and comparing them to the bytes you already uploaded using `s3cmd`.

We have some S3 examples (including PutObject) here: <https://docs.aws.amazon.com/sdk-for-kotlin/latest/developer-guide/kotlin_s3_code_examples.html>

Ah the `part` thing was to copy the data from a callContext to the file to store on the server

The copy part is fine as I can see the file is not corrupted after the user sending the image through to the backend

If the `fileToSend` bytes are fine then something is going wrong in transmission. One thing to consider when using a 3rd party is aws-chunked encoding. It's enabled by default if your <https://github.com/smithy-lang/smithy-kotlin/blob/00500f2f640ec565ad53546a3d660c2eb97b1472/runtime/auth/aws-signing-common/common/src/aws/smithy/kotlin/runtime/auth/awssigning/internal/AwsChunkedUtil.kt#L23|file is larger 1MB>. Not all 3rd party S3 implementations support it, so I'd recommend trying to disable it by configuring `enableAwsChunked = false` on the S3 client

Yeah the `PutObject` definitely lose some data as I checked the request object of the s3client

```/0ab39821-006e-4832-843b-c023ccb1b9aa_IMG_3150.jpeg
x-id=PutObject
amz-sdk-invocation-id:05ac2057-7db8-4877-823c-0afa923bbab0
amz-sdk-request:attempt=1; max=3
content-encoding:aws-chunked
content-type:image/jpeg
host:
x-amz-content-sha256:STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
x-amz-date:20250218T143655Z
x-amz-decoded-content-length:3170304
x-amz-trailer:x-amz-checksum-crc32
x-amz-user-agent:aws-sdk-kotlin/1.4.19

amz-sdk-invocation-id;amz-sdk-request;content-encoding;content-type;host;x-amz-content-sha256;x-amz-date;x-amz-decoded-content-length;x-amz-trailer;x-amz-user-agent
STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
2025-02-18 21:36:55.520 [eventLoopGroupProxy-4-1] TRACE a.s.k.r.a.a.DefaultAwsSignerImpl - String to sign:
AWS4-HMAC-SHA256
20250218T143655Z
20250218/SYD1/s3/aws4_request
312bd01c25e8e4becd7d8d6e54f545151be2669063bf4a1430e24be4a680b134
2025-02-18 21:36:55.521 [eventLoopGroupProxy-4-1] DEBUG a.s.k.r.a.a.DefaultAwsSignerImpl - Calculated signature: 2242b77a4a291cd557b716666e33c8a82333f6ab62a8dea8c2ad8d2643686187
2025-02-18 21:36:55.526 [eventLoopGroupProxy-4-1] DEBUG httpTraceMiddleware - HttpRequest:
PUT /0ab39821-006e-4832-843b-c023ccb1b9aa_IMG_3150.jpeg?x-id=PutObject
Host: 
Content-Type: image/jpeg
User-Agent: aws-sdk-kotlin/1.4.19 ua/2.1 api/s3#1.4.19 os/macos#15.3 lang/kotlin#2.1.0 md/javaVersion#17.0.13 md/jvmName#OpenJDK_64-Bit_Server_VM md/jvmVersion#17.0.13+0 m/Z,b,E,n,U
x-amz-user-agent: aws-sdk-kotlin/1.4.19
amz-sdk-invocation-id: 05ac2057-7db8-4877-823c-0afa923bbab0
amz-sdk-request: attempt=1; max=3
x-amz-trailer: x-amz-checksum-crc32
Expect: 100-continue
Content-Encoding: aws-chunked
Transfer-Encoding: chunked
X-Amz-Decoded-Content-Length: 3170304
X-Amz-Content-Sha256: STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
X-Amz-Date: 20250218T143655Z
Authorization: AWS4-HMAC-SHA256 Credential=DO8014XT97N4P8ZLEV44/20250218/SYD1/s3/aws4_request, SignedHeaders=amz-sdk-invocation-id;amz-sdk-request;content-encoding;content-type;host;x-amz-content-sha256;x-amz-date;x-amz-decoded-content-length;x-amz-trailer;x-amz-user-agent, Signature=2242b77a4a291cd557b716666e33c8a82333f6ab62a8dea8c2ad8d2643686187```

Yeah you can see `content-encoding:aws-chunked`. The 3rd party may not fully support this encoding and might be what's corrupting your data. Try disabling it and let me know if it works

Content-length should be <tel:3632105|3632105>

Hm setting the `enableAwsChunked = false` didn't work out

you have any idea why the `fileToSend` bytes are not fully loaded into the request body?

Can you create a minimal reproduction and open an issue on GitHub? I'm unable to replicate this locally but curious what's going wrong for you.

Ideally using S3 and not a third party implementation. If we can’t replicate using S3 we’d ask that you open an issue with your provider

Sure, I have found a way to circumvent this problem though. By not copying the data to disk and read it directly from the HTTP request body, the data was fully read

Hi, I'm trying to use S3 Client to send files to S3 with aws-sdk-kotlin but idk what happen with Okhttp.
Throws a error about Okhttp NotSuchMethod with something of reflection, Someone have ever solved this issue?

Hi Matthew, `NoSuchMethodError` <https://docs.aws.amazon.com/sdk-for-kotlin/latest/developer-guide/troubleshooting-faqs.html#ts-faq-nusuchmethod|is a likely symptom of a dependency conflict>. Do you possibly have a direct or transitive dependency on OkHttp 4? Because that would conflict with the AWS SDK's default dependency on OkHttp 5.

While OkHttp 5 is the default HTTP engine, there's also <https://github.com/smithy-lang/smithy-kotlin/tree/main/runtime/protocol/http-client-engines/http-client-engine-okhttp4|an OkHttp 4 engine> and a CRT engine, either of which may help you get around the dependency conflict.

Ohh I see now, I'm going to test, if you do not tell me, I would have not found the correctly documentation and location of okhttp4engine

I'm sorry, testing it again throws `Exception in thread "OkHttp Dispatcher" java.lang.NoSuchMethodError: 'void kotlinx.coroutines.CancellableContinuation.resume(java.lang.Object, kotlin.jvm.functions.Function3)'`
And my config with Okthttp4Engine is correctly configured:
```@Bean
suspend fun s3Client(): S3Client = S3Client {
    region = awsRegion
    endpointUrl = Url.parse(url)
    credentialsProvider = StaticCredentialsProvider {
        accessKeyId = accessKey
        secretAccessKey = secretKey
    }
    httpClient = OkHttp4Engine()
}```
Is this possible? or I'm bad? xd

That code looks correct. Does your Gradle configuration *<https://github.com/smithy-lang/smithy-kotlin/tree/main/runtime/protocol/http-client-engines/http-client-engine-okhttp4#gradle|force resolution down to 4.x and exclude the okhttp-coroutines module>*?

Yes, but It does not work, idk why but it does not work.
Buuuut I've found the crt engine that works for me, with this config in gradle:
```implementation(awssdk.services.s3)
implementation(awssdk.runtime.smithy.kotlin.http.client.engine.crt)```
And I found a new error with the checksum to send docs into a bucket, a local bucket using minio docker image.
I don't know what happen but reading a lot I found that the code works like this
```                S3Client.fromEnvironment {
                    region = "us-east-2"
                    endpointUrl = Url.parse("<http://127.0.0.1:9000>")
                    credentialsProvider = StaticCredentialsProvider {
                        accessKeyId = "my_acces_key"
                        secretAccessKey = "my_secret_key"
                    }
                    httpClient = CrtHttpEngine()
                }.use { s3Client -&gt;
                    val fileContentBytes = fileContent.toString(Charsets.UTF_8)

                    val request = PutObjectRequest {
                        bucket = "test"
                        key = UUID.randomUUID().toString() + ".txt"
                        body = ByteStream.fromString(fileContentBytes) 
                        checksumAlgorithm = ChecksumAlgorithm.Sha256
                    }

                    s3Client.putObject(request)
                }```

Yes you may find that Minio functions differently from S3 in various respects. Unfortunately I'm not a Minio expert so I can't offer much advice there.

That said, if you can't get the OkHttp 4 engine to work and you've followed the instructions in the repo, then you might have encountered a bug—or at the very least an area where better logging/diagnostics from the SDK could help you resolve the issue. Consider <https://github.com/awslabs/aws-sdk-kotlin/issues|filing an issue> with a minimal repro.

I'm going to fill the issue this weekend because I have a lot of work :sweat_smile:

Have anyone tried creating an Android/iOS multiplatform module for AWS SDKs? :thinking_face:

A few observations:
1. While AWS do provide a Kotlin multiplatform SDK, it supports only Android/JVM targets. So this leaves us with no choice but to implement the iOS target's handling manually.
2. On the iOS side, there is an AWS Swift SDK, but no Objective-C SDK; Kotlin multiplatform supports Kotlin/Obj-C interop, but there is no direct Kotlin/Swift interop.
It seems difficult to go ahead with this, thoughts?

Hey, we are currently working on adding iOS support to the Kotlin SDK as part of Kotlin/Native: <https://github.com/awslabs/aws-sdk-kotlin/issues/229>

The implementation is mostly complete, and we're working on testing + release infrastructure next. It _*should*_:tm: be available sometime later this year.

Hi, again, have anyone used assume role with kotlin sdk?

Yeah, I've used `sts:AssumeRole` with the SDK. Do you have some questions?

Yup, idk but I want that my micro service use the default roles already config in ECS is possible?

We <https://github.com/awslabs/aws-sdk-kotlin/blob/main/aws-runtime/aws-config/common/src/aws/sdk/kotlin/runtime/auth/credentials/EcsCredentialsProvider.kt|have an >`EcsCredentialsProvider`<https://github.com/awslabs/aws-sdk-kotlin/blob/main/aws-runtime/aws-config/common/src/aws/sdk/kotlin/runtime/auth/credentials/EcsCredentialsProvider.kt| that's enabled> by default if you use `.fromEnvironment { ... }` on your client. It will use the container metadata service to fetch credentials. Is it not working for you?

If you want to assume different credentials, it's possible but will require manually configuring the `credentialsProvider`

It was weird, with:
```        credentialsProvider = DefaultChainCredentialsProvider(
            httpClient = CrtHttpEngine()
        )```
Works for me, but thanks, without your help I would be looking for the error

Hi all, is the s3Client of aws-sdk-kotlin thread-safe? Thank in advance

Yes, the entire SDK is built to work on structured concurrency and coroutines. The same client (e.g., `S3Client`) may be shared across multiple coroutines/threads without conflict.

Is there any particular aspect you're concerned about?

Nothing in particular. I just found out that ktor server spawns a new coroutine to handle each incoming request so I’m reviewing my current architecture to make sure the code will not be racy

No problem, ping us again if you have more questions! :blush:

Hi,
I recently upgraded `com.amplifyframework:aws-auth-cognito` from version 2.14.10 to 2.29.1 for my android app.
Post upgrade, two new Exceptions started being thrown by some users (and the number keeps increasing gradually) when calling `fetchAuthSession()`, namely `ConfigurationException: Identity Pool not configured` and `Exception: Credentials empty, cannot refresh`. For additional context, we do not have have any identity pools set up hence no `CredentialsProvider` in our config file. We would like to know why these could be thrown and what the resolution is for the user to recover form such states. Stack traces in :thread:

```com.amplifyframework.auth.exceptions.ConfigurationException: Identity Pool not configured.
    at com.amplifyframework.auth.cognito.actions.AuthorizationCognitoActions$initializeFetchUnAuthSession$$inlined$invoke$1.execute(Action.kt:72)
    at com.amplifyframework.statemachine.ConcurrentEffectExecutor$execute$1$1.invokeSuspend(ConcurrentEffectExecutor.kt:26)
    at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
    at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:100)
    at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:829)
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:717)
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:704)
com.amplifyframework.auth.exceptions.UnknownException: Fetch auth session failed.
    at com.amplifyframework.auth.cognito.RealAWSCognitoAuthPlugin$_fetchAuthSession$1.invoke(RealAWSCognitoAuthPlugin.kt:1108)
    at com.amplifyframework.auth.cognito.RealAWSCognitoAuthPlugin$_fetchAuthSession$1.invoke(RealAWSCognitoAuthPlugin.kt:1081)
    at com.amplifyframework.statemachine.StateMachine.notifySubscribers(StateMachine.kt:185)
    at com.amplifyframework.statemachine.StateMachine.process(StateMachine.kt:200)
    at com.amplifyframework.statemachine.StateMachine.access$process(StateMachine.kt:55)
    at com.amplifyframework.statemachine.StateMachine$send$1.invokeSuspend(StateMachine.kt:169)
    at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
    at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:100)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:524)
    at java.util.concurrent.FutureTask.run(FutureTask.java:317)
    at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:348)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1156)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:651)
    at java.lang.Thread.run(Thread.java:1119)```

```java.lang.Exception: Credentials empty, cannot refresh.
    at com.amplifyframework.auth.cognito.actions.AuthorizationCognitoActions$initiateRefreshSessionAction$$inlined$invoke$1.execute(Action.kt:86)
    at com.amplifyframework.statemachine.ConcurrentEffectExecutor$execute$1$1.invokeSuspend(ConcurrentEffectExecutor.kt:26)
    at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
    at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:100)
    at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:829)
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:717)
    at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:704)
com.amplifyframework.auth.exceptions.UnknownException: Fetch auth session failed.
    at com.amplifyframework.auth.cognito.RealAWSCognitoAuthPlugin$_fetchAuthSession$1.invoke(RealAWSCognitoAuthPlugin.kt:1108)
    at com.amplifyframework.auth.cognito.RealAWSCognitoAuthPlugin$_fetchAuthSession$1.invoke(RealAWSCognitoAuthPlugin.kt:1081)
    at com.amplifyframework.statemachine.StateMachine.notifySubscribers(StateMachine.kt:185)
    at com.amplifyframework.statemachine.StateMachine.process(StateMachine.kt:200)
    at com.amplifyframework.statemachine.StateMachine.access$process(StateMachine.kt:55)
    at com.amplifyframework.statemachine.StateMachine$send$1.invokeSuspend(StateMachine.kt:169)
    at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
    at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:100)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:487)
    at java.util.concurrent.FutureTask.run(FutureTask.java:264)
    at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:307)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:644)
    at java.lang.Thread.run(Thread.java:1012)```

Hi Artaza, the Amplify Android library uses the AWS SDK under the hood but adds a bunch of its own functionality on top. Neither of the stack traces you provided contain frames related to the AWS SDK so you may have better luck asking on <https://github.com/aws-amplify/amplify-android|Amplify'S GH repo>.