AWS Project day 3

Class 64th AWS Project day 3 July 10th

Create one more lambda function 

Step1:Need to create below lambda function 

Step2: Layer which common code in all database connection code every lambda function, instead of calling all the connection every function to over the repeated entry need to use layer
Environment variables DB_HOST,DB_NAME,DB_USER,  DB_PASS
If you stared with Signup go to loacal singup folder code install the msql pip install pymysql -t.

Create one python directory whatever move to pymsql and pyMSql ..executable file to python folder

Zip the python folder  python.zip

Step3:Create the layer ,upload the Signup zip file and click create layer 

ccit-mysqldb-layer

Step4: Creation of RDS database 

Create Mysql steps:

Aurora and RDS> Create database 

Single(A-Z) DB instance deployment (1 instance)

DB Instance Identifier  :Digital-library

Credential Settings >Self managed  > admin /admin1234

DB Instance Class >Burstable Classes :db.t4g.micro

Public access :Yes 

Click Create database 

Step5:

Endpoint :digital-library.c5iyik8mi7ym.eu-west-2.rds.amazonaws.com

User admin 

password:admin1234

Database Schema creaion: CREATE DATABASE IF NOT EXISTS digital_library; USE digital_library;

CREATE TABLE IF NOT EXISTS users ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100) NOT NULL, mobile VARCHAR(20) NOT NULL, email VARCHAR(100) NOT NULL UNIQUE, password VARCHAR(255) NOT NULL, gender VARCHAR(10), location VARCHAR(100), image VARCHAR(255) );

CREATE TABLE IF NOT EXISTS books ( id INT AUTO_INCREMENT PRIMARY KEY, title VARCHAR(255) NOT NULL, author VARCHAR(255), available BOOLEAN DEFAULT TRUE );

CREATE TABLE IF NOT EXISTS history ( id INT AUTO_INCREMENT PRIMARY KEY, user_id INT, book_id INT, borrow_date DATETIME, return_date DATETIME, FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE, FOREIGN KEY (book_id) REFERENCES books(id) ON DELETE CASCADE );

INSERT INTO books (title, author, available) VALUES ('Wings of Fire', 'A.P.J. Abdul Kalam', TRUE), ('The Guide', 'R.K. Narayan', TRUE), ('Godan', 'Munshi Premchand', TRUE), ('Train to Pakistan', 'Khushwant Singh', TRUE), ('Ignited Minds', 'A.P.J. Abdul Kalam', TRUE), ('Mahabharata', 'Ved Vyasa', TRUE), ('Python Crash Course', 'Eric Matthes', TRUE), ('Digital Fortress', 'Dan Brown', TRUE), ('You Can Win', 'Shiv Khera', TRUE), ('Zero to One', 'Peter Thiel', TRUE);

Step6: add environment variabe 
Environment variables DB_HOST:digital-library.c5iyik8mi7ym.eu-west-2.rds.amazonaws.com
      ,DB_NAME=digital_library,DB_USER=admin ,DB_PASS=admin1234

Step6: Give Connection details to the lambda function click save

Step7: add Layer 

Step8: Select custom layer ,select you layer and version click add 

Step9:Every function add the code deploy and add the environment variable all the remaining functions

Step10:

Step11: Create API Gateways 

Rest API  Click Build  Click Create API

Step12:Create Resource the API,Signup,select below options Create resource 

Step13:Delete the Option methos, create new method for Get method

Step14: Select below option for Signup API choose correspinding lambda function create create method

Step15: Create resouce Signin Click create resource 

Step16:Delete the exist Option metho,Click create method for Signin Click 

Step17:Need create all resource and create methods.

Step18:Create Deploy API ,after deploy all the url copy from the method,past them in you main 

app.py file

Step19:Copy all url from the API,past that into your code

Step20:Modify the exist project code ,like below and execute

Step21: We missed Integration Input parameter adding Signup Click Save 

Step22:Signin Integration mapping templated 

{

  "email": "$input.params('email')",

  "password": "$input.params('password')"

}

Step23: After changes Click deploy API

Step22:

Step23: Data inserted Successfully 

Step24: Every not required upload lambda function runtime file to All lambda function instead of them you just add the layer for the every lambda function

Added the layer customize

 Add same layer similar all database connection lambda function click add

This is the completed Code 

--Thanks

AWS Project day 2

 Class 63rd AWS Project day 2 July 9th

Using all below services

IAM, Completed

KMS, Encrypt the password Completed

VPC, 

EC2,(LB,AS,EBS,EFS),

Local to RDS,     Completed

DynamoDB,

Lambda,    Completed

API Gateway,

S3,   Completed

CloudFront  Completed

Route53,

ACM

Last Class 62nd Above service completed, using CloudFront Images stored in private bucket 

It should retrieved from the s3 private bucket 

Step1:

Need Create CloudFront distributed url select the Origin private while you creating 

Step2: I have uploaded app_cloudfront.py take reference and execute rename app.py

 >python app.py

https://github.com/Vakatisubbu/DigitalLibrary

Step3:Image column CloudFront, image stored database.

Step4: KMS , password encrypted 

Lambda using our project 

lambda_function.py

import json

import pymysql

db_config = {  

    'host': 'aurorabd.csn64oem2jvs.us-east-1.rds.amazonaws.com',

    'user': 'admin',

    'password': 'admin123',

    'database': 'digital_library'

}

def lambda_handler(event, context):

    try:

        # 🔍 Debug full event structure

        print("FULL EVENT:", json.dumps(event))

        # ✅ Pull query parameters

        body = event if isinstance(event, dict) else {}

        print("Query Params:", json.dumps(body))

        # Extract

        name = body.get('name')

        mobile = body.get('mobile')

        email = body.get('email')

        password = body.get('password')

        gender = body.get('gender')

        location = body.get('location')

        image = body.get('image')

        if not all([name, mobile, email, password,gender,location,image]):

            return {

                "statusCode": 400,

                "body": json.dumps({

                    "status": "fail",

                    "message": "Missing required fields",

                    "received": body  # <-- debug: show what was received

                })

            }

        conn = pymysql.connect(**db_config)

        cursor = conn.cursor()

        cursor.execute("SELECT * FROM users WHERE email = %s", (email,))

        if cursor.fetchone():

            cursor.close()

            conn.close()

            return {

                "statusCode": 409,

                "body": json.dumps({"status": "fail", "message": "Email already exists"})

            }

        cursor.execute("""

            INSERT INTO users (name, mobile, email, password, gender, location, image)

            VALUES (%s, %s, %s, %s, %s, %s, %s)

        """, (name, mobile, email, password, gender, location, image))

        conn.commit()

        cursor.close()

        conn.close()

        return {

            "statusCode": 200,

            "body": json.dumps({"status": "success", "message": "User created successfully"})

        }

    except Exception as e:

        print("Exception:", str(e))

        return {

            "statusCode": 409,

            "body": json.dumps({"status": "error", "message": str(e)})

        }

C:\Users\Administrator\Desktop\Lambda>pip install pymysql -t.

Collecting pymysql

  Using cached PyMySQL-1.1.1-py3-none-any.whl.metadata (4.4 kB)

Using cached PyMySQL-1.1.1-py3-none-any.whl (44 kB)

Installing collected packages: pymysql

Successfully installed pymysql-1.1.1

Select this files Zip it

pymysql

PyMySQL-1.1.1.dist-info

lambda_function.py

Step5: upload the zip folder 

Click Deploy

Step6: 

API Gateway  >Reset API > Resoure>SignUp> create Methods >GET >

Click Integration edit m

Mapping template

{

   "name": "$input.params('name')",

   "mobile": "$input.params('mobile')",

   "email": "$input.params('email')",

   "password":"$input.params('password')",

   "gender": "$input.params('gender')",

   "location":"$input.params('location')",

   "image": "$input.params('image')"

}

Click Save 

Click Deploy API 

Step7:

Tested Query Script parameter 

Step8: Record save successfully in database.

Step9: Create one more  function name 

ccit-lambda-function-Sigin.py

While Selecting the role Same role Lambda function we can not use,until unless the role has administrator permission

import json
import pymysql
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

db_config = {
    'host': 'aurorabd.csn64oem2jvs.us-east-1.rds.amazonaws.com',
    'user': 'admin',
    'password': 'admin123',
    'database': 'digital_library',
    'connect_timeout': 5
}


def lambda_handler(event, context):
    try:
        # Debug logging
        logger.info(f"Raw event structure: {json.dumps(event)}")

        # Handle both proxy and non-proxy integrations
        if event.get('queryStringParameters'):
            data = event['queryStringParameters']
        elif event.get('body'):
            try:
                body = event['body']
                data = json.loads(body) if isinstance(body, str) else body
            except json.JSONDecodeError:
                data = {}
        else:
            data = event

        logger.info(f"Parsed data: {data}")

        email = data.get('email')
        password = data.get('password')

        if not email or not password:
            return {
                "statusCode": 400,
                "headers": {"Content-Type": "application/json"},
                "body": json.dumps({
                    "status": "fail",
                    "message": "Email and password required",
                    "received": data
                })
            }

        # Database connection
        try:
            conn = pymysql.connect(**db_config)
            with conn.cursor() as cursor:
                cursor.execute(
                    "SELECT id, name, email FROM users WHERE email = %s AND password = %s",
                    (email, password)
                )
                user = cursor.fetchone()

            if user:
                response = {
                    "statusCode": 200,
                    "headers": {"Content-Type": "application/json"},
                    "body": json.dumps({
                        "status": "success",
                        "user": {
                            "id": user[0],
                            "name": user[1],
                            "email": user[2]
                        }
                    })
                }
            else:
                response = {
                    "statusCode": 401,
                    "headers": {"Content-Type": "application/json"},
                    "body": json.dumps({
                        "status": "fail",
                        "message": "Invalid credentials"
                    })
                }

            logger.info(f"Returning response: {response}")
            return response

        except pymysql.MySQLError as e:
            logger.error(f"Database error: {str(e)}")
            return {
                "statusCode": 500,
                "headers": {"Content-Type": "application/json"},
                "body": json.dumps({
                    "status": "error",
                    "message": "Database error"
                })
            }

    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        return {
            "statusCode": 500,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({
                "status": "error",
                "message": "Internal server error"
            })
        }

C:\Users\Administrator\Desktop\Lambda\SignIn>pip install pymysql -t.

Collecting pymysql

  Using cached PyMySQL-1.1.1-py3-none-any.whl.metadata (4.4 kB)

Using cached PyMySQL-1.1.1-py3-none-any.whl (44 kB)

Installing collected packages: pymysql

Successfully installed pymysql-1.1.1

Step7: Create resource Signin 

Delete the existing Option method 

Click Create Method

Step8:Intergration

{

  "email": "$input.params('email')",

  "password": "$input.params('password')"

}

Click Save 

Step 10: Create one more Lambda Function 

For test 

{

  "body": "{\"email\":\"prabhu@gmail.com\",\"password\":\"prabhu\"}",

  "queryStringParameters": null

}

Signup the detail using lambda function

import json
import pymysql
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

db_config = {
    'host': 'aurorabd.csn64oem2jvs.us-east-1.rds.amazonaws.com',
    'user': 'admin',
    'password': 'admin123',
    'database': 'digital_library',
    'connect_timeout': 5
}


def lambda_handler(event, context):
    try:
        # Debug logging
        logger.info(f"Raw event structure: {json.dumps(event)}")

        # Handle both proxy and non-proxy integrations
        if event.get('queryStringParameters'):
            data = event['queryStringParameters']
        elif event.get('body'):
            try:
                body = event['body']
                data = json.loads(body) if isinstance(body, str) else body
            except json.JSONDecodeError:
                data = {}
        else:
            data = event

        logger.info(f"Parsed data: {data}")

        email = data.get('email')
        password = data.get('password')

        if not email or not password:
            return {
                "statusCode": 400,
                "headers": {"Content-Type": "application/json"},
                "body": json.dumps({
                    "status": "fail",
                    "message": "Email and password required",
                    "received": data
                })
            }

        # Database connection
        try:
            conn = pymysql.connect(**db_config)
            with conn.cursor() as cursor:
                cursor.execute(
                    "SELECT id, name, email FROM users WHERE email = %s AND password = %s",
                    (email, password)
                )
                user = cursor.fetchone()

            if user:
                response = {
                    "statusCode": 200,
                    "headers": {"Content-Type": "application/json"},
                    "body": json.dumps({
                        "status": "success",
                        "user": {
                            "id": user[0],
                            "name": user[1],
                            "email": user[2]
                        }
                    })
                }
            else:
                response = {
                    "statusCode": 401,
                    "headers": {"Content-Type": "application/json"},
                    "body": json.dumps({
                        "status": "fail",
                        "message": "Invalid credentials"
                    })
                }

            logger.info(f"Returning response: {response}")
            return response

        except pymysql.MySQLError as e:
            logger.error(f"Database error: {str(e)}")
            return {
                "statusCode": 500,
                "headers": {"Content-Type": "application/json"},
                "body": json.dumps({
                    "status": "error",
                    "message": "Database error"
                })
            }

    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        return {
            "statusCode": 500,
            "headers": {"Content-Type": "application/json"},
            "body": json.dumps({
                "status": "error",
                "message": "Internal server error"
            })
        }

Step11:

--Thanks 

Class 62nd AWS Trusted Advisor

Class 62nd AWS Trusted Advisor and Project day 1 ,July 8th

What is the trusted advisor?
ACM -Aws certificate manager 
What is the AWS ACM?
What are SSL/TLS Certificates?
Types of AWS ACM?
Key features of AWS ACM.
How AWS ACM Works?
Limitations of AWS ACM.

Ticket cases :

Account and Billing related queries 

Service limit increases

Technical Assistance

 

Basic Support -Free                           Support 

Account and Billing related queries  yes

Service limit increases                         yes

Technical Assistance                            no 

No technical assistance from AWS 

AWS Developer forums access 

Knowledge base articles and AWS docs

Trusted advisor :only core area checks 

Developer Support -From 29$ per month          Support 

Account and Billing related queries                         yes

Service limit increases                                              yes

Technical Assistance                                                 yes

 

12-24 Local business hours support 

Char and email support from cloud support associate

Start from $29/-per month 

Trusted advisor :only core area checks 

One user can raise ticket

Business Support -From 100$ per month          Support 

Account and Billing related queries                         yes

Service limit increases                                              yes

Technical Assistance                                                 yes

With in 1hr support available

24*7 support 

Cloud engineer provides the help

Email,phone and char support

Trusted advisor:Full area checks

Multiple users can raise tickets

Enterprise Support -From 15000$ per month         (Company related only)

$15000/-per month

with in 15 mints support available

Sr. Cloud engineer support

AWS Training and allocate TAM(Technical Account manager)

Annual operational review and architectural reviews

Trusted advisor: Full area checks

Multiple users can raise ticket

AWS trusted advisor

AWS trusted advisor is a cloud optimization service provided by  amazon web services(AWS).

It is an essential tools for AWS users who want to ensure their cloud environment is optimized, secure, and cost-effective.

it helps users optimize their AWS infrastructure by offering real-time guidance in five key areas: Cost Optimization, performance, security, fault tolerance, service limits

and Operational excellence.

AWS Trusted Advisor continuously scans you AWS environment, providing insights though a dashboard that displays check and recommendations.

User can then implement these recommendations directly or with the assistance of AWS support.

AWS Trusted advisor

Benefits

Cost savings: By identifying unused or underutilize resources, trusted advisor helps reduce costs.

Improved Security: It ensures that your AWS Environment adheres to security best practices.

Enhances performance: it offers suggestions to improve the performance of you AWS workload.

Increase Fault tolerance: Recommendations are provided to improve the resilience of your architecture.

Practical:

As we are free limitation trusted advisor only few checks perform completely in our account level

(Cost Optimation, performance, Security,Fault tolerance,service limitations,Operation excellence) Recommendation will provide ,below navigation

>Trusted Advisor>Recommendations

Step1:

As see below ,one of the S3 bucket security policy was broken, given public access

Step2: 1 Immediate action,3 for investigation optional case ,0 if you are not security compliance showing here

Some security group ,some issue unrestricted ,ports are enabled All traffic ,need to remove this security group

Step3: After deleted security immediate trusted advisor ,refresh automatically

ACM -AWS Certificate manager 
 

What is the AWS ACM?

What are SSL/TLS certificates?

Types of AWS ACM?

Key Features of AWS ACM.

How AWS ACM Works?

Limitations of AWS ACM.

What is the AWS ACM?(free)

Aws certificate Manage(ACM) is a manager service that allows you to provision, mange, and deploy

SSL/TLS certificates for securing websites and applications running on AWS.

It simplifies the processes of obtaining and renewing certificates, making it easier to enable HTTPS(secure communication) for your domains.

What are SSL/TLS Certificates?

SSL (Secure sockets Layer) and TLS(Transport Layer Security) certificates are digital certificates that secure communication between a web server and a user's browser by encrypting data.

What is an SSL certificate?

SSL Was the original protocol designed to secure internet communication.

it established an encrypted connection between clients(browsers) and servers. However, SSL is now outdated and insecure.

what is a TLS Certificate?

TLS is the modern and more secure replacement for SSL,it provides the same encryption but with stronger security algorithms.

Most people still call them "SSL Certificates" but in reality, today's certificates use TLS encryption

ACM Certificates for internal user only 

AWS ACM(Amazon Certificate manager) provides free SSL/TLS certificates for use with AWS services like ALB,cloudfront,and API gateway.

For customer installations(Ec2,On-prem servers),you may need to buy a certificate from thrid-party providers like dificert, Globalsign, or Let's Encrypt(free option).

Are SSL/TLS Certificates Free?

ACM certificates for internal use only

AWS ACM(Amazon Certificate manager) Provides free SSL/TLS Certificates for use with AWS services like ALB,cloudfront,and API Gateway.

For custom installations(Ec2,on-prem servers),you may need to buy a certificate from third-party providers like digicert,globalsign,or Lets encrypt(free option)

Types of AWS ACM ?

AWS Certificate manager(ACM) provides certificates in 2 types 

Public and private certificates

Feature :    Public                                                      Private (internal)

Visibility  Trusted globally by  all browsers         Only Trusted  within internal networks 

Use case   Used for websites,APIs,and external  Used for internal services like intranet,VPNS,and                            Servers                                                private APIs

Issued by Public certificate authorities(CA)like  AWS private CA(your own CA)

                 amazon,digicert            

Pricing      Free (in AWS ACM)                           Requires AWS private CA(paid)

validation  Doamin validation required               No Public validation needed

examples https://yourwebsite.com(accessuble https://internal.yourcompany.com(used within the                                to the world)                                                   company)

                    

Key features of AWS ACM.

Free SSL.TLS certificates

 .ACM Provides free SSL/TLS certificates for domains managed within AWS.

 These Certificates are issued by Amazon trust services.

Automatic renewal

 ACM automatically renews certificates  before they expire, eliminating manual efforts

  

Domain validation(DV)

To get a certifcate,you must verify domain ownership using:

 1.Emal validation(sending a verification email to the domain owner)

 2.DNS validation(Adding a CNAME record in Route 53)

How AWS ACM Works?

1. Requesting a certificate 

    In AWS console, go to certificate manager(ACM) >request certificate.

   Enter your domain name (eg.example.com)

   Choose validation method(Email or DNS)

   If using DNS,ACM Provides a CNAME record to add to Route 53

2. Validation Process

   If using DNS Validation, ACM checks for the correct CNAME records in Route 53

  Once validated,the certificate is issued.

3.Deploying the Certificate

  Attach the issued certificate to an  application load balancer (ALB),CloudFront, or API Gateway

 Configure, a HTTPs listener(port 443) for secure traffic.

limitation  of AWS ACM

 ACM certificates for internal use only 

 You cannot download ACM certificates for use outside AWS(e.g on a standardlone server)

 To Use and external SSL certificate,you must import it into ACM

 On Supports AWS-integrated services 

  ACM certificates can only be used with AWS service like ALB,cloudFront,and API Gateway.

  Cannot be installed on Ec2 instances directly(for that ,use Let's Encrypt or buy a certificate from an external provider)

Regional scope

ACM Certificate are region-specific ,except for cloudfrontm,which uses certificates from ACM in Us-east-1

Pricing:

AWS ACM in free for public SSL/TLS certificates are long as they are used with AWS-intergrated service like:

Application load balancer 

CloudFont(CDN)

API Gateway

AWS APP Runner 

What costs Money?

Private certificates(issuse via AWS Private CA)

If you need an internal(Private)certificate for internal apps, you must use AWS private cerificate Authority(CA),which is not free 

Route 53 Domain registration(optional)

If you domain is registered with route 53,you pay for domain registration(e.g $12 year for .com domains)

CloudFront Usage

ACM certificates are free ,but use them with cloudfront ,you pay for cloudfront data transfer.

                                                         

                                           Cloud Front S3 Static Page Hosting

Step1:Need to create one S3 Bucket ,With Public Access ccitpublicbucket and upload the static 

index.html page 

Step2:Give Bucket policy like this

{

    "Version": "2012-10-17",

    "Statement": [

        {

            "Sid": "Statement2",

            "Effect": "Allow",

            "Principal": "*",

            "Action": "s3:*",

            "Resource": "arn:aws:s3:::ccitpublicbucket/*"

        }

Step3: Static we can not directly do static page hosted into hosted zone, using cloud front url 

we can able to hosted the static page 

CloudFront creation 

Need to select Origin S3

Click Next select Do not enable security Protections, Click next and create Distribution

Step4: SSL certificate creation

AWS Certificate Manager>Certificate >Request Certificate

Request Public certificate 

Give you Domain name For me:vakatisubbu.xyz

click Request 

While create request you add enter Cname to Route 53

Route 53 cname enter is created 

Step5: Hosted zone give you domain name

Step6:Cname records created ,A record you need add you cloudFront distrinutation endpoint

Step7:After SSL certificate attached to CloudFront

Sep8: Cloud Distribution Validation add Object /* click create optional

Step9: Prior Godaddy website, where you brough the domain ,you need custom dns

nameservers you need enter your NS enters which was exist 4 url add ,after add only  ACM will be issued

Step11:After SSL Certificate, Static page opened  

 

                                                                Project1

Using all below services

IAM,

KMS, Encrypt the password

VPC,

EC2,(LB,AS,EBS,EFS),

Local to RDS,     Completed

DynamoDB,

Lambda,

API Gateway,

S3,   Completed

Route53,

ACM

This Local Mysql Project Library :https://github.com/Vakatisubbu/DigitalLibrary.git

Above Project is Local DB Need change this RDS 

Step1:Create Aurora DBA Mysql

Aurora DB>Mysql

Template>Free Tier

DB Instance Identifier: Auroradb (any name)

Credential setting>Self managed(master password confirm password)

Instance Configuration >Burastable 

Public Access >yes

Click Create database

Using the DB connections detail connect Mysql your local

CREATE DATABASE IF NOT EXISTS digital_library; USE digital_library;

CREATE TABLE IF NOT EXISTS users ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100) NOT NULL, mobile VARCHAR(20) NOT NULL, email VARCHAR(100) NOT NULL UNIQUE, password VARCHAR(255) NOT NULL, gender VARCHAR(10), location VARCHAR(100), image VARCHAR(255) );

CREATE TABLE IF NOT EXISTS books ( id INT AUTO_INCREMENT PRIMARY KEY, title VARCHAR(255) NOT NULL, author VARCHAR(255), available BOOLEAN DEFAULT TRUE );

CREATE TABLE IF NOT EXISTS history ( id INT AUTO_INCREMENT PRIMARY KEY, user_id INT, book_id INT, borrow_date DATETIME, return_date DATETIME, FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE, FOREIGN KEY (book_id) REFERENCES books(id) ON DELETE CASCADE );

INSERT INTO books (title, author, available) VALUES ('Wings of Fire', 'A.P.J. Abdul Kalam', TRUE), ('The Guide', 'R.K. Narayan', TRUE), ('Godan', 'Munshi Premchand', TRUE), ('Train to Pakistan', 'Khushwant Singh', TRUE), ('Ignited Minds', 'A.P.J. Abdul Kalam', TRUE), ('Mahabharata', 'Ved Vyasa', TRUE), ('Python Crash Course', 'Eric Matthes', TRUE), ('Digital Fortress', 'Dan Brown', TRUE), ('You Can Win', 'Shiv Khera', TRUE), ('Zero to One', 'Peter Thiel', TRUE);

Db configuration file you need change the connection details ,run the launch the application

C:\Users\Administrator\Desktop\AWS_projects\DigitalLibrary>python app.py

https://github.com/Vakatisubbu/DigitalLibrary.git

Signup with details User tables insert records successfully.

Login above detail and take some books 

History table Records are inserted successfully.

Login image We plan store in S3 bucket, Our ccitpublicbucket existing code need enable ACL 

After enable 

S3 Images are stored Successfully.

Click the image icon right inspect,get know where image coming , here clearly showing the image coming from S3 bucket.

--Thanks 

CloudFormation Project

CloudFormation Project

Class 54th AWS CloudFormation June 28th project

Practical

Step1:

Step2: Give any name stackname : ccit-stack-Prj-nonat Click Next 

Step3:Select the role, and check I acknowledge Click Next and then Click Submit

--Thanks