What is the purpose of AWS Sumerian AR/VR scenes and hosts in TypeScript

Question

Pulumi · Accepted Answer

AWS Sumerian is a managed service provided by Amazon Web Services that enables developers to create and run augmented reality (AR), virtual reality (VR), and 3D applications quickly and with minimal specialized programming or 3D graphics expertise. With AWS Sumerian, you can build highly immersive and interactive scenes that could be used for a variety of applications such as training simulations, virtual concierge services, product visualizations, and interactive storytelling.

In the context of using AWS Sumerian with Pulumi and TypeScript, Pulumi does not directly interact with Sumerian as it focuses more on the infrastructure level of cloud services. Since Sumerian is a high-level application service, it doesn’t have specific resources that are managed through Infrastructure as Code (IaC) tools like Pulumi typically.

However, to integrate a Sumerian scene into a web application, you would typically need to configure various AWS resources such as Amazon S3 for hosting the web application, Amazon Cognito for authentication, and potentially Amazon API Gateway and AWS Lambda for any serverless computing needs. Using Pulumi with TypeScript, you can define and deploy these accompanying cloud resources to facilitate and serve your AWS Sumerian application.

Below is a basic example of a Pulumi program, written in TypeScript, which sets up an S3 bucket for hosting a web application, configures a Cognito user pool for authentication, and prepares an API Gateway with a Lambda function. This would be part of the backend infrastructure you might use in an AWS Sumerian project:

```typescript
import * as aws from "@pulumi/aws";

// Create an Amazon S3 bucket to host the web application
const s3Bucket = new aws.s3.Bucket("sumerian-app-bucket", {
    website: {
        indexDocument: "index.html",
    },
});

// Create an AWS Cognito user pool for managing user authentication
const userPool = new aws.cognito.UserPool("sumerian-user-pool", {
    passwordPolicy: {
        minimumLength: 8,
        requireLowercase: true,
        requireUppercase: true,
        requireNumbers: true,
        requireSymbols: true,
    },
});

// Create an AWS Cognito user pool client
const userPoolClient = new aws.cognito.UserPoolClient("sumerian-app-client", {
    userPoolId: userPool.id,
    generateSecret: false,
});

// Create a Lambda function that will process API requests
const apiLambda = new aws.lambda.Function("sumerianApiHandler", {
    code: new pulumi.asset.AssetArchive({
        ".": new pulumi.asset.FileArchive("./app"),  // path to your Lambda source code
    }),
    runtime: aws.lambda.NodeJS12dXRuntime,
    handler: "index.handler",  // the entrypoint into your Lambda code
    role: lambdaRole.arn,  // an IAM role with appropriate permissions for the Lambda
});

// Set up API Gateway to trigger the Lambda function
const apiGateway = new aws.apigatewayv2.Api("sumerianApiGateway", {
    protocolType: "HTTP",
});

const integration = new aws.apigatewayv2.Integration("sumerianApiLambdaIntegration", {
    apiId: apiGateway.id,
    integrationType: "AWS_PROXY",
    integrationUri: apiLambda.arn,
    payloadFormatVersion: "2.0",
});

new aws.apigatewayv2.Route("sumerianApiRoute", {
    apiId: apiGateway.id,
    routeKey: "POST /",
    target: pulumi.interpolate`integrations/${integration.id}`,
});

// Export necessary values
export const bucketName = s3Bucket.bucket;
export const userPoolId = userPool.id;
export const userPoolClientId = userPoolClient.id;
export const apiEndpoint = apiGateway.apiEndpoint;
```

This code block defines the necessary AWS resources to run a basic backend for a web application that could include AWS Sumerian content. The S3 bucket hosts the web application files, AWS Cognito provides user authentication, and API Gateway along with Lambda handles backend logic.

Note that this does not include the AWS Sumerian AR/VR scenes and hosts themselves, as those would need to be created using the Sumerian editor and then integrated into your web application. For using the Sumerian service itself, you would do that through the AWS Sumerian console or the AWS SDK, and not typically through infrastructure-as-code with Pulumi.