Implementing a streaming analytics solution for social media using AWS Kinesis, processing with Lambda, and storing in Amazon Aurora

Sure, I can suggest a basic architecture for your requirement. It includes AWS Kinesis for the streaming data, AWS Lambda for processing the data, and Amazon Aurora as the database for storing the processed data.

Here's an outline for the Pulumi program that sets this up in Python:

1. Create an AWS Kinesis stream.
2. Create an AWS IAM role that the Lambda function can assume for reading from the Kinesis stream and writing to the Aurora DB.
3. Create an AWS Lambda function specifying the ARN of the role just created.
4. Create an Amazon RDS Aurora instance.
5. Output the IDs/names of the created resources for inspection.

Remember to fill-in with your actual code to process data within the Lambda function (currently it's a placeholder), and also replace the Aurora configuration with your specific details.

Here's the Pulumi python program.

import pulumi
from pulumi_aws import iam, kinesis, lambda_, rds

# Create a Kinesis stream
stream = kinesis.Stream("mystream")

# Create AWS IAM role
lambda_role = iam.Role("lambdaRole",
    assume_role_policy="""{
      "Version": "2012-10-17",
      "Statement": [
        {
          "Action": "sts:AssumeRole",
          "Principal": {
            "Service": "lambda.amazonaws.com"
          },
          "Effect": "Allow",
          "Sid": ""
        }
      ]
    }"""
)

# Attach policy to IAM role for Lambda
assume_role_policy = iam.RolePolicy("lambdaRolePolicy",
    role=lambda_role.id,
    policy="""{
        "Version": "2012-10-17",
        "Statement": [
            {
                "Action": ["kinesis:*", "rds:*"],
                "Effect": "Allow",
                "Resource": "*"
            }
        ]
    }"""
)

# Create AWS Lambda function
lambda_function = lambda_.Function('myfunction',
                                   role=lambda_role.arn,
                                   runtime="nodejs12.x",
                                   handler="index.handler",
                                   code=pulumi.AssetArchive({
                                       '.': pulumi.FileArchive('./app')
                                   }))

# Create an RDS instance
cluster = rds.Cluster("my-cluster",
    engine="aurora-mysql",
    engine_version="5.7.mysql_aurora.2.07.2",
    master_username="admin",
    master_password="password",
    skip_final_snapshot=True,
)

# Export names/IDs of created resources
pulumi.export('stream_name', stream.name)
pulumi.export('lambda_function_name', lambda_function.name)
pulumi.export('rds_cluster_id', cluster.cluster_identifier)

Remember, this will create an AWS Kinesis stream, a Lambda function and an RDS instance in your AWS account that could potentially cost money.

For more information, visit:

• AWS Kinesis Stream
• AWS Lambda Function
• AWS IAM Role
• AWS RDS Aurora

You could run this program by executing pulumi up in the directory containing this code and following the command-line prompts. Please replace placeholders with real values and handle all errors and exceptions, and note that the Aurora instance will be publicly accessible.