> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Demo Pre requisite to Deploy Application
> This lesson covers manual steps to install and configure an EC2 environment without Cloud9 IDE, including IAM role creation and application deployment with AWS CDK.
In this lesson, you will perform the manual steps required to install and configure an EC2 environment when [Cloud9 IDE](https://aws.amazon.com/cloud9/) is not available. You’ll create an IAM role, launch and prepare an EC2 instance, clone repositories, configure your AWS environment, and deploy with AWS CDK.
These steps mimic the Cloud9 IDE setup by granting the EC2 instance permissions via an IAM role and installing all required CLI tools, Docker, Kubernetes clients, and CDK.
***
## 1. Create an IAM Role for EC2
1. Open the IAM console, choose **Roles** → **Create role**.
2. Select **AWS service** and **EC2** use case, then **Next**.
3. Attach these AWS managed policies:
| Policy Name | Description |
| ---------------------------- | ----------------------------------------- |
| AdministratorAccess | Full administrative access |
| AmazonSSMManagedInstanceCore | Systems Manager permissions for instances |
4. Use the exact trust policy and name from the GitHub repo (e.g., `fisworkshop-admin`):
```json theme={null}
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
5. Complete the role creation.
6. (Optional) Verify the role’s summary and trust relationships.
***
## 2. Launch an EC2 Instance
1. In the EC2 console, click **Launch instance**.
2. Name the instance, choose **Amazon Linux** AMI, and select an instance type (e.g., `m5.xlarge` for CDK deployments).
3. (Optional) Create or choose an SSH key pair for shell access.
Opening SSH (port 22) to `0.0.0.0/0` is insecure. Restrict to your IP range where possible.
4. Keep default VPC/subnet and allow SSH access.
5. Under **Storage**, increase the root volume size to meet lab requirements.
6. In **Advanced Details**, select the IAM instance profile you created (`fisworkshop-admin`) to grant AWS API permissions.
7. Launch and confirm success.
8. Wait until your instance is **running** & passes **2/2 status checks**.
***
## 3. Connect and Prepare the EC2 Environment
1. Select your instance, click **Connect** → **EC2 Instance Connect**.
If EC2 Instance Connect isn’t available, use your SSH key pair and `ssh -i ec2-user@`.
2. Switch to root:
```bash theme={null}
sudo su -
clear
```
3. Install Git and clone the repository:
```bash theme={null}
yum install -y git
git clone https://github.com/nasiauallas/FaultInjectionSimulator-KodeKloud.git
```
4. Run the prerequisites script:
```bash theme={null}
cd FaultInjectionSimulator-KodeKloud/Manual_IDE
chmod +x pre-req-manual-ide.sh
./pre-req-manual-ide.sh
```
This installs Docker, `kubectl`, Helm, `eksctl`, Node.js, AWS CDK, and more. You should see versions such as:
```bash theme={null}
Git version: 2.40.1
Docker version: 25.0.6
AWS CDK version: 2.6.0
kubectl version: v1.29.0
Helm version: v3.13.0
eksctl version: 0.180.0
Node.js version: v22.6.0
```
***
## 4. Clone the AWS FIS Workshop
Create a workspace and clone the official AWS Fault Injection Simulator workshop:
```bash theme={null}
mkdir -p ~/environment/workshopfiles
git clone https://github.com/aws-samples/aws-fault-injection-simulator-workshop-v2.git ~/environment/workshopfiles/fis-workshop
```
***
## 5. Configure AWS Environment Variables
Set your account ID and region for all CLI calls:
```bash theme={null}
export AWS_PAGER=""
export ACCOUNT_ID=$(aws sts get-caller-identity --output text --query Account)
export AWS_REGION=$(aws ec2 describe-availability-zones --output text --query 'AvailabilityZones[0].RegionName')
echo "export ACCOUNT_ID=${ACCOUNT_ID}" >> ~/.bash_profile
echo "export AWS_REGION=${AWS_REGION}" >> ~/.bash_profile
aws configure set default.region "${AWS_REGION}"
aws configure get default.region
```
Validate your IAM role assignment:
```bash theme={null}
aws sts get-caller-identity --query Arn \
| grep fisworkshop-admin -q \
&& echo "You're good. IAM role IS valid." \
|| echo "IAM role NOT valid. DO NOT PROCEED."
```
***
## 6. Deploy the Application with AWS CDK
1. Navigate to your CDK project (e.g., `pet_stack`), install dependencies, and fix audits:
```bash theme={null}
cd pet_stack
npm install
npm audit fix
```
2. Bootstrap the CDK environment:
```bash theme={null}
cdk bootstrap
```
You should see output like:
```text theme={null}
Bootstrapping environment aws://123456789012/us-east-1...
Building Docker image for AWS Lambda...
Deploying CDKToolkit stack...
CREATE_COMPLETE CloudFormationStack CDKToolkit
```
3. Confirm in CloudFormation that **CDKToolkit** is in `CREATE_COMPLETE`.
***
## 7. Final Deployment Steps
1. Export your current role ARN and deploy the full stack (may take \~30 minutes):
```bash theme={null}
export CONSOLE_ROLE_ARN=$(aws sts get-caller-identity --query Arn --output text)
echo $CONSOLE_ROLE_ARN
cd pet_stack
cdk deploy --require-approval never
```
2. After deployment completes, explore the next experiments in:
`~/environment/workshopfiles/fis-workshop`.
***
## Links and References
* [AWS IAM Documentation](https://docs.aws.amazon.com/iam/latest/UserGuide/introduction.html)
* [Amazon EC2 User Guide](https://docs.aws.amazon.com/ec2/)
* [AWS CDK Developer Guide](https://docs.aws.amazon.com/cdk/latest/guide/home.html)
* [AWS Fault Injection Simulator Workshop](https://github.com/aws-samples/aws-fault-injection-simulator-workshop-v2)
* [Docker Hub](https://hub.docker.com/)