[Yandex Cloud documentation](../../index.md) > [Yandex Cloud Notification Service](../index.md) > [Tools](index.md) > AWS SDK for Python (boto3)

# Getting started with the AWS SDK for Python (boto3) in Yandex Cloud Notification Service

{% note info %}

The service is at the [preview stage](../../overview/concepts/launch-stages.md).

{% endnote %}

[boto3](https://github.com/boto/boto3) is a software development kit (SDK) for the Python 3.x programming language. The SDK is designed for working with services compatible with the [Amazon SNS API](https://docs.aws.amazon.com/sns/latest/api/welcome.html).

To get started with the AWS SDK for Python (boto3):
1. [Get your cloud ready](#before-you-begin).
1. [Get a static access key](#static-key).
1. [Configure the AWS SDK](#aws-sdk).
1. [Create a notification channel](#create-channel).
1. [Get a list of channels](#list-channel).
1. [Create an endpoint](#create-endpoint).
1. [Send a notification](#publish).

## Get your cloud ready {#before-you-begin}

Sign up for Yandex Cloud and create a [billing account](../../billing/concepts/billing-account.md):
1. Navigate to the [management console](https://console.yandex.cloud) and log in to Yandex Cloud or create a new account.
1. On the **[Yandex Cloud Billing](https://center.yandex.cloud/billing/accounts)** page, make sure you have a billing account linked and it has the `ACTIVE` or `TRIAL_ACTIVE` [status](../../billing/concepts/billing-account-statuses.md). If you do not have a billing account, [create one](../../billing/quickstart/index.md) and [link](../../billing/operations/pin-cloud.md) a cloud to it.

If you have an active billing account, you can create or select a [folder](../../resource-manager/concepts/resources-hierarchy.md#folder) for your infrastructure on the [cloud page](https://console.yandex.cloud/cloud).

[Learn more about clouds and folders here](../../resource-manager/concepts/resources-hierarchy.md).

## Get a static access key {#static-key}

For authentication in Cloud Notification Service, use a [static access key](../../iam/concepts/authorization/access-key.md). The key is issued for the [service account](../../iam/concepts/users/service-accounts.md), and all actions are performed on behalf of that service account.

To get a static access key:
1. [Create](../../iam/operations/sa/create.md) a service account.
1. [Assign](../../iam/operations/sa/assign-role-for-sa.md) the `editor` [role](../../iam/roles-reference.md#editor) for the folder to the service account.
1. [Create](../../iam/operations/authentication/manage-access-keys.md#create-access-key) a static access key for the service account.

    Save the ID and secret key.

## Configure the AWS SDK {#aws-sdk}

1. [Install Python](https://wiki.python.org/moin/BeginnersGuide/Download).
1. Install the AWS SDK for Python (boto3) using this command:

    ```bash
    pip install boto3
    ```

1. Create a client:

    ```python
    import boto3

    client = boto3.client(
        "sns",
        endpoint_url="https://notifications.yandexcloud.net/",
        region_name="ru-central1",
        aws_access_key_id="<static_key_ID>",
        aws_secret_access_key="<secret_key>",
        verify=False # Disable SSL verification for notifications.yandexcloud.net
    )
    ```

    Where:
    * `aws_access_key_id`: Static key ID.
    * `aws_secret_access_key`: Secret key.

## Create a notification channel {#create-channel}

```python
response = client.create_platform_application(
    Name="<channel_name>",
    Platform="<platform_type>",
    Attributes= {
         "<параметр1>": "<значение1>",
         ...
         "<parameterN>": "<valueN>"
    }
)
print ("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 `"<parameter>": "<value>"` format, comma-separated. 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](https://docs.openssl.org/1.1.1/man1/pkcs12) Linux utility:
          
          ```bash
          openssl pkcs12 -in Certificates.p12 -nokeys -nodes -out certificate.pem
          openssl pkcs12 -in Certificates.p12 -nocerts -nodes -out privatekey.pem
          ```

    Token-based authentication is preferred as a more modern option.

  * 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.

    The HTTP v1 API is preferred as [FCM will no longer support](https://firebase.google.com/docs/cloud-messaging/migrate-v1) the Legacy API starting June 2024.

  * HMS:

    * `PlatformPrincipal`: Key ID.
    * `PlatformCredential`: API key.

  * RuStore:
  
    * `PlatformPrincipal`: Project ID (ProjectID).
    * `PlatformCredential`: Service token (ServiceToken).

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

## Get a list of notification channels {#list-channel}

```python
response = client.list_platform_applications()
for app in response["PlatformApplications"]:
    print("Application ARN:", app["PlatformApplicationArn"])
```

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

## Create an endpoint {#create-endpoint}

```python
response = client.create_platform_endpoint(
    PlatformApplicationArn="<notification_channel_ARN>",
    Token="<push_token>",
)
print ("Endpoint ARN:", response["EndpointArn"])
```

Where:

* `PlatformApplicationArn`: Notification channel ID (ARN).
* `Token`: Unique push token for the app on the user’s device.

As a result, you will get a mobile endpoint ID (ARN).


## Send a notification {#publish}

### Explicit notifications (Bright Push) {#bright-push}

{% list tabs %}

- Apple iOS (APNs)

  ```python
  response = client.publish(
      TargetArn="<endpoint_ID>",
      Message=json.dumps({
          "default": "<notification_text>",
          "APNS": json.dumps({
              "aps": {
                  "alert": "<notification_text>"
              }
          })
      }),
      MessageStructure="json"
  )
  print ("Message id:", response["MessageId"])
  ```

- Google Android (FCM)

  ```python
  response = client.publish(
      TargetArn="<endpoint_ID>",
      Message=json.dumps({
          "default": "<notification_text>",
          "GCM": json.dumps({
              "notification": {
                  "body": "<notification_text>"
              }
          })
      }),
      MessageStructure="json"
  )
  print ("Message id:", response["MessageId"])
  ```

- RuStore Android

  ```python
  response = client.publish(
      TargetArn="<endpoint_ID>",
      Message=json.dumps({
          "default": "<default_notification_text>",
          "RUSTORE": json.dumps({
              "notification": {
                  "title": "<notification_title>",
                  "body": "<notification_text>",
              }
          })
      }),
      MessageStructure="json"
  )
  message_id = response["MessageId"]
  print(f"Message id is: {message_id}")
  ```

{% endlist %}

Where:
* `TargetArn`: Mobile endpoint ARN.
* `MessageStructure`: Message format.
* `Message`: Message.

### Silent notifications (Silent Push) {#silent-push}

```python
response = client.publish(
    TargetArn="<endpoint ARN>",
    Message='{"data": { "key": "value" } }')
print ("Message id:", response["MessageId"])
```

Where:
* `TargetArn`: Mobile endpoint ARN.
* `Message`: Message.

## Examples {#examples}

### Sending SMS {#sms-sending}

```python
client.publish(PhoneNumber="<recipient_phone_number>",
    Message="<notification_text>",
    MessageAttributes={
        "AWS.SNS.SMS.SenderID": {
            "DataType": "String",
            "StringValue":"<sender's_text_name>"
        }
    }
)
```

Where:
* `PhoneNumber`: Russian phone number in [E.164](https://en.wikipedia.org/wiki/E.164) format.
* `Message`: SMS text.
* `MessageAttributes`: SMS attributes, where `AWS.SNS.SMS.SenderID.StringValue` is the sender's text name.

## Useful links {#see-also}

* [Getting started](../quickstart.md)
* [AWS CLI](aws-cli.md)
* [Concepts](../concepts/index.md)