node.js – how can i fix the error ERR_CONNECTION_TIMED_OUT?

Here is my App.js file (client side) :

import React,{useContext,useState} from 'react'
import {Button,Form} from 'semantic-ui-react' 
import axios from 'axios'
import { useAlert } from 'react-alert'

import {AuthContext} from '../context/auth'

export default function Register(props) {
    const context = useContext(AuthContext)
    const (values,setValues)=useState({
        name:'',
        email:'',
        password:''
    })

    const (errors,setErrors)=useState({});
   
    const alert = useAlert()

    const onChange=(e)=>{
        setValues({...values,(e.target.name):e.target.value})
    }

    const onSubmit=(e)=>{
        e.preventDefault();
        console.log(values);
        axios.post('http://54.83.252.172:5000/api/v1/register',values)
        .then(resp=>{
            if(resp.data.msg==="User successfully created"){
                context.login(values);
                alert.show(<div style={{ color: 'green' }}>"Successfully Registered"</div>)
                props.history.push('/') 
            }else{
                alert.show(<div style={{ color: 'red' }}>"Enter valid details"</div>)
            }
                     
        })
        .catch(err=>{
            alert.show(<div style={{ color: 'red' }}>"Enter a Valid Email, username, password "</div>)    
        })
    }

    return (
        <div className="form-container">
            <Form onSubmit={onSubmit} noValidate>
                <h1>Register</h1>
                <Form.Input
                  label='Username'
                  placeholder="name.."
                  name="name"
                  value={values.username}
                  onChange={onChange}  required />
                  <Form.Input
                //   type='email'
                  label='Email'
                  placeholder="Email.."
                  name="email"
                  value={values.email}
                  onChange={onChange}  required/>
                  <Form.Input
                //   type='password'
                  label='password'
                  placeholder="password.."
                  name="password"
                  value={values.password}
                  onChange={onChange} required/>

                  <Button type="submit" primary>
                      Register
                  </Button>
                 </Form>

                  {Object.keys(errors).length>0 &&(
                    <div className="ui error message">
                     <ul className="list">
                        {Object.values(errors).map(value=>(
                            <li key={value}>{value}</li>
                        ))}
                     </ul>

                 </div>
                  )}

                 
        </div>
    )
}

and this is my main.py file (server side) :

from flask import Flask,jsonify,request, render_template,jsonify
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.sql import and_,or_,exists
from flask_cors import CORS,cross_origin
#import Model
import datetime
from sqlalchemy.orm import validates,backref, lazyload
from werkzeug.security import (generate_password_hash, 
  check_password_hash)
import re
import os
from flask_marshmallow import Marshmallow,Schema,fields
from marshmallow import Schema,fields



app = Flask(__name__)
#cors = CORS(app, resources={r"/api/*": {"origins": "*"}})
CORS(app)

#basedir=os.path.abspath(os.path.dirname(__file__))
app.config('SQLALCHEMY_DATABASE_URI')='sqlite:///C:/Program Files/nodejs/React-App/backend/data.db'
app.config('SQLALCHEMY_TRACK_MODIFICATIONS')=False


db = SQLAlchemy(app) # Khoi tao sqlalcemy
ma = Marshmallow(app) # khoi tao Marshmallow


#user model
class User(db.Model):
    blogposts=db.relationship('Blogpost',backref='blog_owner')
    user_id=db.Column(db.Integer,primary_key=True)
    name=db.Column(db.String(100),index=True,unique=True)
    email=db.Column(db.String(100),unique=True,index=True)
    password=db.Column(db.String(100),unique=True)
    created_on = db.Column(db.DateTime, server_default=db.func.now())

    # def set_password(self, password): 
    #   self.password = generate_password_hash(password) 
    
    @validates('name') 
    def validate_username(self, key, name):
        if not name:
            raise AssertionError('No username provided')
        if User.query.filter(User.name == name).first():
            raise AssertionError('Username is already in use')
        if len(name) < 5 or len(name) > 20:
            raise AssertionError('Username must be between 5 and 20 characters') 
        return name 
    @validates('email') 
    def validate_email(self, key, email):
        if not email:
            raise AssertionError('No email provided')
        if not re.match("(^@)+@(^@)+.(^@)+", email):
            raise AssertionError('Provided email is not an email address') 
        return email  
       

    def __init__(self,name,email,password):
        self.name=name
        self.email=email
        self.password=password      



# Blog model one to many association
class Blogpost(db.Model):
     id=db.Column(db.Integer,primary_key=True)
     post=db.Column(db.String(100),nullable=True)
     blog_owner_id=db.Column(db.Integer,db.ForeignKey('user.user_id'))
     created_on = db.Column(db.DateTime, server_default=db.func.now())

     def __init__(self,post,blog_owner_id):
         self.post=post  
         self.blog_owner_id=blog_owner_id     
# --------------------------------------------------------------            

class BlogSchema(ma.Schema):
    class Meta:
       
        fields=("id","post","blog_owner_id","created_on")

blog_schema= BlogSchema(many=True)

# user Schemal
class UserSchema(ma.Schema):
        user_id=fields.Integer()
        name = fields.Str()
        email = fields.Str()
        password=fields.Str()
        blogposts=ma.Nested(blog_schema,many=True)
        created_on=fields.DateTime()


# init schema
user_schema = UserSchema()
users_schema= UserSchema(many=True)



# GET,POST,PUT,PATCH,DELETE

@app.route('/', methods=('GET'))
def index():
   return "hello!"

@app.route("/home", methods=('GET'))
def home():
    return render_template("index.html")

@app.route('/abc',methods=('GET','POST'))
def abc():
   a = {
       "CustomerID":1,
       "name":"lvminh"
   }
   return jsonify(a)

@app.route('/api/v1/register',methods=('POST'))
@cross_origin()
def add_user(): 
    data = request.get_json()
    name = data('name')
    password = data('password')
    email = data('email')
    
    new_user=User(name=name,email=email,password=password)
    try:
            db.session.add(new_user)
            db.session.commit()
            return jsonify(msg='User successfully created'), 200
    except AssertionError as exception_message: 
            return jsonify(msg='Error: {}. '.format(exception_message)), 400    

@app.route('/api/v1/login',methods=('POST'))
@cross_origin()
def userlogin():
    email=request.json('email')
    password=request.json('password')
    # db.session.query(db.exists().where(User.email == email and User.password== password))
    if  email and password != "":
        all_user=User.query.all()
        for u in all_user:
            if(u.email==email and u.password==password):
                return jsonify({"status":"User exists","username":u.name})
    return jsonify({'msg':'no user exists '})    

# all users
@app.route('/api/v1/users',methods=('GET'))
def get_users():
    all_user=User.query.all()
    result=users_schema.dump(all_user)
    return jsonify(result)

@app.route('/api/v1/user/<user_id>',methods=('GET'))
def get_user(user_id):
    only_user=User.query.get(user_id)
    return user_schema.jsonify(only_user)    


@app.route('/api/v1/user/<user_id>',methods=('PUT'))
def update_user(user_id):
    user = User.query.get(user_id)
   # name=request.json('name')
    email=request.json('email')
    # user.name=name
    user.email=email   
    db.session.commit()
    return user_schema.jsonify(user) 


# Deleting a user
@app.route('/api/v1/user/<user_id>',methods=('DELETE'))
def delete_user(user_id):
    only_user=User.query.get(user_id)
    # blog_data=Blogpost.query.get()
    db.session.delete(only_user)
    db.session.commit()
    return user_schema.jsonify(only_user)        
    
# --------------------------------------------------------------
# posts of specific user
@app.route('/api/v1/users/<user_id>',methods=('POST'))
def posts(user_id):
    post=request.json('post')
    if request.method=='POST':
        if post!='':
          new_post=Blogpost(post,user_id)
          db.session.add(new_post)
          db.session.commit()
          return user_schema.jsonify(User.query.get(user_id)) 
    return jsonify("Post is empty")  

@app.route('/api/v1/users/allblogs',methods=('GET'))
def blogs():
    allblogs=Blogpost.query.all()
    result=blog_schema.dump(allblogs)
    return jsonify(result)



@app.route('/api/v1/users/blog/<user_id>',methods=('GET'))
def userblogs(user_id):
   
    userblogs=Blogpost.query.filter_by(blog_owner_id=user_id).order_by(Blogpost.id.desc()).all()
    result=blog_schema.dump(userblogs)
    return jsonify(result)

            
if __name__ == '__main__':
    db.create_all()
    app.run(port=5000,host="0.0.0.0",debug=True)

when i start react app and app flask , connected, no problem with database But when i press subscribe button no data is sent to my DB and i have these messages in my Tools for Chrome developers:

POST http://54.83.252.172:5000/api/v1/register net::ERR_CONNECTION_TIMED_OUT

What can I do to fix that please ?