PolarDB:Using the DynamoDB-compatible feature

Configure network access

Choose the connection method based on where your application runs.

• Private connection (recommended): If your application runs on an Alibaba Cloud Elastic Compute Service (ECS) instance in the same Virtual Private Cloud (VPC) as the PolarDB cluster, add the ECS instance's IP address or security group to the cluster's whitelist.

• Internet connection: For local development and testing, request an Internet endpoint for the DynamoDB endpoint in the Database Connections section on the Basic Information page.

  Accessing the cluster over the Internet poses security risks. Use an Internet endpoint only for temporary development and testing, and release it when you are done.

  

Verify the connection with Python (Boto3)

The following example uses the Boto3 SDK on an ECS instance running Alibaba Cloud Linux 3.2104 LTS 64-bit to verify the connection.

When connecting to PolarDB's DynamoDB-compatible feature, region_name must be set to an empty string ("").

1. Create the project directory.

   mkdir /home/testDynamoDB
   cd /home/testDynamoDB

2. Create and activate a virtual environment to isolate project dependencies.

   python3 -m venv myenv
   source myenv/bin/activate

3. Install Boto3.

   pip3 install boto3

4. Create main.py with the following code. Replace endpoint_url, aws_access_key_id, and aws_secret_access_key with the endpoint and DynamoDB account details of your PolarDB cluster.

   import boto3
   from botocore.exceptions import ClientError
   
   # 1. Configure your connection details
   # The endpoint URL for your PolarDB cluster
   endpoint_url = "http://<your-polardb-ddb-endpoint>:<port>"
   # The Access Key ID for your DynamoDB account
   aws_access_key_id = "<your-access-key-id>"
   # The Secret Access Key for your DynamoDB account
   aws_secret_access_key = "<your-secret-access-key>"
   # For the DynamoDB-compatible feature of PolarDB, region_name must be an empty string.
   region_name = ""
   
   # 2. Create a DynamoDB resource client
   dynamodb = boto3.resource(
       'dynamodb',
       endpoint_url=endpoint_url,
       aws_access_key_id=aws_access_key_id,
       aws_secret_access_key=aws_secret_access_key,
       region_name=region_name,
   )
   
   table_name = 'usertable'
   
   # 3. Define functions for database operations
   def create_table():
       """Creates the table, or gets it if it already exists."""
       try:
           table = dynamodb.create_table(
               TableName=table_name,
               KeySchema=[{'AttributeName': 'userid', 'KeyType': 'HASH'}], # Partition key
               AttributeDefinitions=[{'AttributeName': 'userid', 'AttributeType': 'S'}]
               # ProvisionedThroughput is optional and ignored by PolarDB
           )
           print("Creating table... Waiting for it to become active.")
           table.meta.client.get_waiter('table_exists').wait(TableName=table_name)
           print("Table is active!")
           return table
       except ClientError as e:
           if e.response['Error']['Code'] == 'ResourceInUseException':
               print("Table already exists.")
               return dynamodb.Table(table_name)
           else:
               raise
   
   def put_items(table):
       """Puts a few items into the table."""
       users = [
           {'userid': 'user01', 'name': 'Alice', 'age': 24},
           {'userid': 'user02', 'name': 'Bob', 'age': 30},
           {'userid': 'user03', 'name': 'Charlie', 'age': 28}
       ]
       for user in users:
           table.put_item(Item=user)
       print("Inserted 3 items.")
   
   def scan_table(table):
       """Scans and prints all items in the table."""
       response = table.scan()
       items = response.get('Items', [])
       print(f"Scanned {len(items)} items:")
       for item in items:
           print(item)
   
   def delete_table(table):
       """Deletes the table."""
       table.delete()
       print("Deleting table... Waiting for it to be removed.")
       table.meta.client.get_waiter('table_not_exists').wait(TableName=table_name)
       print("Table deleted successfully.")
   
   # 4. Run the verification process
   if __name__ == '__main__':
       try:
           user_table = create_table()
           put_items(user_table)
           scan_table(user_table)
       finally:
           # Ensure the table is cleaned up even if errors occur
           if 'user_table' in locals():
               delete_table(user_table)

5. Run the script. The script creates a table, inserts three items, scans them, and then deletes the table.

   python3 main.py

   The expected output is:

   Creating table... Waiting for it to become active.
   Table is active!
   Inserted 3 items.
   Scanned 3 items:
   {'age': Decimal('24'), 'name': 'Alice', 'userid': 'user01'}
   {'age': Decimal('30'), 'name': 'Bob', 'userid': 'user02'}
   {'age': Decimal('28'), 'name': 'Charlie', 'userid': 'user03'}
   Deleting table... Waiting for it to be removed.
   Table deleted successfully.

   This output confirms a successful connection and that all configurations are working correctly.