Yandex Cloud
Search
Contact UsGet started
  • Blog
  • Pricing
  • Documentation
  • All Services
  • System Status
    • Featured
    • Infrastructure & Network
    • Data Platform
    • Containers
    • Developer tools
    • Serverless
    • Security
    • Monitoring & Resources
    • ML & AI
    • Business tools
  • All Solutions
    • By industry
    • By use case
    • Economics and Pricing
    • Security
    • Technical Support
    • Customer Stories
    • Cloud credits to scale your IT product
    • Gateway to Russia
    • Cloud for Startups
    • Education and Science
    • Yandex Cloud Partner program
  • Blog
  • Pricing
  • Documentation
© 2025 Direct Cursus Technology L.L.C.
Yandex Cloud Notification Service
    • Overview
    • Getting started with mobile push notifications
    • Getting started with in-browser push notifications
    • Getting started with SMS
    • Overview
    • Mobile push notifications
    • In-browser push notifications
    • SMS
    • Quotas and limits
    • All tools
    • AWS CLI
    • AWS SDK for C++
    • AWS SDK for Go
    • AWS SDK for Java
    • AWS SDK for JavaScript
    • AWS SDK for Kotlin
    • AWS SDK for .NET
    • AWS SDK for PHP
    • AWS SDK for Python (boto3)
  • Pricing policy
  • Monitoring metrics
  • Logs Cloud Logging
  • Release notes

In this article:

  • Get your cloud ready
  • Get a static access key
  • Configure the AWS SDK
  • Get your OS ready
  • Create a project
  • Create a notification channel
  • Get a list of notification channels
  • Create an endpoint
  • Send a notification
  • Explicit notifications (Bright Push)
  • Silent notifications (Silent Push)
  • Text message
  • See also
  1. Tools
  2. AWS SDK for Kotlin

How to get started with the AWS SDK for Kotlin in Yandex Cloud Notification Service

Written by
Yandex Cloud
Updated at May 7, 2025
  • Get your cloud ready
  • Get a static access key
  • Configure the AWS SDK
    • Get your OS ready
    • Create a project
  • Create a notification channel
  • Get a list of notification channels
  • Create an endpoint
  • Send a notification
    • Explicit notifications (Bright Push)
    • Silent notifications (Silent Push)
    • Text message
  • See also

Note

The service is at the preview stage.

To get started with the AWS SDK for Kotlin:

  1. Get your cloud ready.
  2. Get a static access key.
  3. Configure the AWS SDK.
  4. Create a notification channel.
  5. Get a list of channels.
  6. Create an endpoint.
  7. Send a notification.

Get your cloud readyGet your cloud ready

Sign up in Yandex Cloud and create a billing account:

  1. Navigate to the management console and log in to Yandex Cloud or register a new account.
  2. On the Yandex Cloud Billing page, make sure you have a billing account linked and it has the ACTIVE or TRIAL_ACTIVE status. If you do not have a billing account, create one and link a cloud to it.

If you have an active billing account, you can navigate to the cloud page to create or select a folder for your infrastructure to operate in.

Learn more about clouds and folders.

Get a static access keyGet a static access key

For authentication in Cloud Notification Service, use a static access key. The key is issued for the service account, and all actions are performed on behalf of that service account.

To get a static access key:

  1. Create a service account.

  2. Assign the editor role for the folder to the service account.

  3. Create a static access key for the service account.

    Save the ID and secret key.

Configure the AWS SDKConfigure the AWS SDK

You can find the prerequisites and an AWS SDK for Kotlin installation guide in the relevant AWS documentation.

To work with RuStore Android notifications, see this RuStore SDK article.

Get your OS readyGet your OS ready

  1. Install Java 8 or higher, e.g., Oracle Java SE Development Kit. For other JDKs you can use with the AWS SDK, see the AWS developer guide.
  2. Install Gradle.

Create a projectCreate a project

  1. Create a new project:

    1. Run this command:

      gradle init --type kotlin-application --dsl kotlin
      
    2. Select the default value for each message by pressing Enter in interactive mode.

  2. Add dependencies to the settings.gradle.kts file in the project root:

    dependencyResolutionManagement {
        repositories {
            mavenCentral()
        }
    
        versionCatalogs {
            create("awssdk") {
                from("aws.sdk.kotlin:version-catalog:1.4.0")
            }
        }
    }
    

    You can replace 1.4.0 with the latest version of the SDK for Kotlin.

  3. Copy the following code to the gradle/libs.versions.toml file:

    [versions]
    junit-jupiter-engine = "5.10.3"
    
    [libraries]
    junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit-jupiter-engine" }
    
    [plugins]
    kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version = "2.1.0" }
    
  4. Copy the following code to the app/build.gradle.kts file:

    plugins {
        alias(libs.plugins.kotlin.jvm)
        application
    }
    
    
    dependencies {
        implementation(awssdk.services.sns) // Add dependency on the AWS SDK for Kotlin's SNS client.
    
        testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
        testImplementation(libs.junit.jupiter.engine)
        testRuntimeOnly("org.junit.platform:junit-platform-launcher")
    }
    
    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(21)
        }
    }
    
    application {
        mainClass = "org.example.AppKt"
    }
    
    tasks.named<Test>("test") {
        useJUnitPlatform()
    }
    
  5. Create a client in the app/src/main/kotlin/org/example/App.kt file:

    package org.example
    
    import aws.sdk.kotlin.services.sns.SnsClient
    import aws.smithy.kotlin.runtime.net.url.Url
    import aws.sdk.kotlin.runtime.auth.credentials.StaticCredentialsProvider
    import aws.smithy.kotlin.runtime.auth.awscredentials.Credentials
    
    import kotlinx.coroutines.runBlocking
    
    suspend fun main(): Unit = runBlocking {
        val snsClient = SnsClient {
            region = "ru-central1"; endpointUrl =
            Url.parse("https://notifications.yandexcloud.net/"); credentialsProvider =
            StaticCredentialsProvider(
                Credentials(
                    "<static_key_ID>",
                    "<secret_key>"
                )
            )
        }
    
        // Use snsClient
    }
    

    Where credentialsProvider contains the static key ID and secret key.

  6. To start the project, run this command:

    gradle run
    

Create a notification channelCreate a notification channel

  1. Import the classes:

    import aws.sdk.kotlin.services.sns.model.CreatePlatformApplicationRequest
    
  2. Run the following code:

    snsClient.use {
        val response = snsClient.createPlatformApplication(CreatePlatformApplicationRequest {
            name = "<channel_name>"
            platform = "<platform_type>"
            attributes = mapOf("<authentication_type>" to "<key>")
        })
        println("Platform application ARN: ${response.platformApplicationArn}")
    }
    

    Where:

    • name: Notification channel name, user-defined.

      The name must be unique throughout CNS. Once the channel is created, you will not be able to change the name. The name may contain lowercase and uppercase Latin letters, numbers, underscores, hyphens, and periods. It must be from 1 to 256 characters long. For APNs channels, we recommend specifying the bundle ID in the name; for FCM and HMS, the full package name; for RuStore, packageName.

    • platform: Mobile platform type:

      • APNS and APNS_SANDBOX: Apple Push Notification service (APNs). Use APNS_SANDBOX to test the application.
      • GCM: Firebase Cloud Messaging (FCM).
      • HMS: Huawei Mobile Services (HMS).
      • RUSTORE: RuStore Android.
    • attributes: Mobile platform authentication parameters in key=value format. The values depend on the platform:

      • APNs:

        • Token-based authentication:

          • PlatformPrincipal: Path to the token signature key file from Apple
          • PlatformCredential: Key ID
          • ApplePlatformTeamID: Team ID
          • ApplePlatformBundleID: Bundle ID
        • Certificate-based authentication:

          • PlatformPrincipal: SSL certificate in .pem format

          • PlatformCredential: Certificate private key in .pem format

            To save the certificate and the private key in individual .pem files, use the openssl Linux utility:

            openssl pkcs12 -in Certificates.p12 -nokeys -nodes -out certificate.pem
            openssl pkcs12 -in Certificates.p12 -nocerts -nodes -out privatekey.pem
            

        Token-based authentication: The more modern and secure method.

      • FCM: PlatformCredential is the Google Cloud service account key in JSON format for authentication with the HTTP v1 API or API key (server key) for authentication with the legacy API.

        Use the HTTP v1 API because the FCM legacy API is no longer supported starting July 2024.

      • HMS:

        • PlatformPrincipal: Key ID
        • PlatformCredential: API key

    As a result, you will get a notification channel ID (ARN).

Get a list of notification channelsGet a list of notification channels

  1. Import the classes:

    import aws.sdk.kotlin.services.sns.model.ListPlatformApplicationsRequest
    
  2. Run the following code:

    snsClient.use {
        val response = snsClient.listPlatformApplications(ListPlatformApplicationsRequest {})
        response.platformApplications?.forEach { app ->
            println("Application ARN: ${app.platformApplicationArn}")
        }
    }
    

    You will get the list of notification channels located in the same folder as the service account.

Create an endpointCreate an endpoint

  1. Import the classes:

    import aws.sdk.kotlin.services.sns.model.CreatePlatformEndpointRequest
    
  2. Run the following code:

    snsClient.use {
        val response = snsClient.createPlatformEndpoint(CreatePlatformEndpointRequest {
            platformApplicationArn = "<notification_channel_ARN>"
            token = "<push_token>"
        })
        println("Endpoint ARN: ${response.endpointArn}")
    }
    

    Where:

    • platformApplicationArn: Notification channel ID (ARN).
    • token: Unique push token for the application on the user’s device.

Send a notificationSend a notification

Explicit notifications (Bright Push)Explicit notifications (Bright Push)

  1. Import the classes:

    import aws.sdk.kotlin.services.sns.model.PublishRequest
    
  2. Run the following code:

    Apple iOS (APNs)
    Google Android (GCM)
    snsClient.use {
        val response = snsClient.publish(PublishRequest {
            targetArn = "<endpoint_ARN>"
            message = "{\"default\": \"<notification_text>\", \"APNS\": \"{\\\"aps\\\": {\\\"alert\\\": \\\"<notification_text>\\\"}}\"}"
            messageStructure = "json"
        })
        println("Message id: ${response.messageId}")
    }
    
    snsClient.use {
        val response = snsClient.publish(PublishRequest {
            targetArn = "<endpoint_ARN>"
            message = "{\"default\": \"<notification_text>\", \"GCM\": \"{\\\"notification\\\": {\\\"body\\\": \\\"<notification_text>\\\"}}\"}"
            messageStructure = "json"
        })
        println("Message id: ${response.messageId}")
    }
    

    Where:

    • targetArn: Mobile endpoint ID (ARN)
    • message: Message
    • messageStructure: Message format

Silent notifications (Silent Push)Silent notifications (Silent Push)

  1. Import the classes:

    import aws.sdk.kotlin.services.sns.model.PublishRequest
    
  2. Run the following code:

    Apple iOS (APNs)
    Google Android (GCM)
    snsClient.use {
        val response = snsClient.publish(PublishRequest {
            targetArn = "<endpoint_ARN>"
            message = "{\"default\": \"<notification_text>\", \"APNS\": \"{\\\"key\\\": \\\"value\\\"}\"}"
            messageStructure = "json"
        })
        println("Message id: ${response.messageId}")
    }
    
    snsClient.use {
        val response = snsClient.publish(PublishRequest {
            targetArn = "<endpoint_ARN>"
            message = "{\"default\": \"<notification_text>\", \"GCM\": \"{\\\"data\\\": {\\\"key\\\": \\\"value\\\"}}\"}"
            messageStructure = "json"
        })
        println("Message id: ${response.messageId}")
    }
    

    Where:

    • targetArn: Mobile endpoint ID (ARN)
    • message: Message
    • messageStructure: Message format

Text messageText message

  1. Import the classes:

    import aws.sdk.kotlin.services.sns.model.PublishRequest
    import aws.sdk.kotlin.services.sns.model.MessageAttributeValue
    
  2. Run the following code:

    snsClient.use {
        val response = snsClient.publish(PublishRequest {
            phoneNumber = "<phone_number>"
            message = "<notification_text>"
            messageAttributes = mapOf("AWS.SNS.SMS.SenderID" to MessageAttributeValue {
                dataType = "String"; stringValue = "<text_name_of_sender>"
            })
        })
        println("Message id: ${response.messageId}")
    }
    

    Where:

    • phoneNumber: Recipient's phone number
    • message: Notification text
    • stringValue: Sender's text name

See alsoSee also

  • Getting started
  • AWS CLI
  • Concepts
  • AWS developer guide

Was the article helpful?

Previous
AWS SDK for JavaScript
Next
AWS SDK for .NET
© 2025 Direct Cursus Technology L.L.C.