Deploy React App with AWS CDK
Tags: aws, awscdk, cdk, react
Published: 2023-11-18 05:57:56

---
title: Deploy React App with AWS CDK
published: true
date: 2023-01-29 04:30:40 UTC
tags: #aws #awscdk #cdk #react
canonical_url: https://blog.mikaeels.com/deploy-react-app-with-aws-cdk
---

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xz3bbftwr2zuf9hti0nh.jpeg)

Building and deploying a React application can be a daunting task, especially when it comes to deploying to a production environment. However, using the AWS Cloud Development Kit (CDK) and TypeScript, you can easily automate the deployment process and make it more manageable. In this tutorial, we will show you how to deploy a React application using AWS CDK and TypeScript.

The first step is to set up a new CDK project. We will use the CDK CLI to initialize a new project and select the `typescript` template.

```
cdk init --language=typescript
```

Once the project is set up, we can start building our application stack. The CDK allows us to define our infrastructure as code, which makes it easy to version control and automate the deployment process. We will use the `aws-cdk-lib/aws-s3` package to create an S3 bucket that will host our React application.

```
import { Stack, StackProps } from 'aws-cdk-lib';
import { Bucket } from 'aws-cdk-lib/aws-s3';

export class ReactDeploymentStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    const reactDeploymentBucket = new Bucket(this, 'ReactDeploymentBucket', {
      websiteIndexDocument: 'index.html',
      websiteErrorDocument: 'index.html',
      publicReadAccess: true,
    });
  }
}
```

Once we have our S3 bucket set up, we can build our React application and deploy it to the bucket. We will use the `create-react-app` CLI to create a new React application and then build it for production.

```
npx create-react-app my-app
cd my-app
npm run build
```

After the build process is complete, we can use the `aws-cli` to sync the build files with our S3 bucket.

```
aws s3 sync build/ s3://<your-bucket-name>
```

Now, we can use the `aws-cdk-lib/aws-cloudfront` package to create a CloudFront distribution that will serve our React application to users.

```
import { CloudFrontWebDistribution } from 'aws-cdk-lib/aws-cloudfront';

const distribution = new CloudFrontWebDistribution(
      this,
      'ReactDeploymentDistribution',
      {
        originConfigs: [
          {
            s3OriginSource: {
              s3BucketSource: reactDeploymentBucket,
            },
            behaviors: [{ isDefaultBehavior: true }],
          },
        ],
      }
    );
```

Finally, To output the URLs of both cloudfront and s3 bucket.

```
import { CfnOutput, Stack, StackProps } from 'aws-cdk-lib';

new CfnOutput(this, 'WebsiteURL', {
      value: reactDeploymentBucket.bucketWebsiteUrl,
      description: 'URL of the website',
    });

new CfnOutput(this, 'CloudFrontDistributionDomainName', {
      value: distribution.distributionDomainName,
      description: 'CloudFront Distribution Domain Name',
    });
```

We have now built a serverless web application using AWS CDK and React. The application is hosted on an S3 bucket and served to users via CloudFront. The CDK makes it easy to automate the deployment process, and the React framework allows us to build responsive and dynamic user interfaces.

It's worth noting that this is a simple example, in a real-world scenario you would likely want to add more features such as Authentication, Authorization, and a database to store your data, but the principles outlined in this tutorial can be applied to more complex applications as well.

One important aspect to consider when building a serverless web application is security. By default, the S3 bucket created in this tutorial allows public read access to all objects, which could be a security concern in some cases. To mitigate this, you can use the `blockPublicAccess` property to block public access to the bucket, and use an Identity and Access Management (IAM) policy to grant access only to specific users or roles.

Another important aspect is scalability. The serverless architecture allows the application to automatically scale in response to changes in traffic, but it's important to properly configure the resources to ensure that they can handle the desired level of traffic. For example, you can use the `aws-cdk-lib/aws-autoscaling` package to automatically scale your CloudFront distribution based on CloudWatch metrics.

In conclusion, building a serverless web application with AWS CDK and React is a great way to take advantage of serverless technologies' scalability, cost-efficiency, and ease of deployment. The AWS CDK makes it easy to define and manage the infrastructure as code, while React allows you to build responsive and dynamic user interfaces. Remember to consider security and scalability when building your serverless web application.

You can find the GitHub repo of the code below.

[https://github.com/mikaeelkhalid/react-deployment-aws-cdk](https://github.com/mikaeelkhalid/react-deployment-aws-cdk)