Giters

archit15singh / react_django_boilerplate

Boilerplate for Django (Django Rest Framework) React (with React-Bootstrap for styling) Web Application. It uses Docker, Docker-Compose, Nginx, and PostgreSQL

Geek Repo:Geek Repo

Github PK Tool:Github PK Tool

React Django Boilerplate

Python version Django version Django-RestFramework version PostgreSQL version React version

React Image Django Image Nginx Image PostgreSQL Image Docker Image

Table of Contents

  1. Description
  2. Tech Stack and Packages Installed
  3. Install (Run) with Docker
  4. Install without Docker
  5. Structure for Docker-Compose Explained
  6. Django Files and Folders of Interest
  7. React Files and Folders of Interest
  8. About Nginx Configuration
  9. Useful Links
  10. Contributing

Description

This repository contains a simple boilerplate project setup for Django + React applications. It is intended to have the minimal amount of packages installed by default, and it has a ready-to-test default configuration for Docker.

For example, see Fullstack Web Home Key Renovations. Home Key Renovations (HKR) is a fullstack website that has this repository as base template.

Tech Stack and Packages Installed

  • Django: This is the backbone of the backend api, and has the following packages installed:

    • Django Rest Framework (For the Rest API)
    • Pillow (For managing images uploading)
    • Django-Cors-Headers (For the CORS config to allow React js to make calls)
    • Django-Environ (To Fetch the environment variables in the settings.py files)
    • Psycopg2-binary (To manage the PostgreSQL Database)
    • Gunicorn (To manage the running instance of the django web app)

    Note: All this packages are specified in the requirements.txt file inside the django_backend folder. Links to their official documentation can be found at the Useful Links section.

  • React: The frontend library in use. This was created via npx create-react-app. The only extra packages that were installed (ignoring the ones that are automatically pre-installed) are:

    • Bootstrap and React-Bootstrap (For styling)
    • Axios (To make calls to the Django Backend)

    Note: The bootstrap css link has been added to the index.js file that is inside the react_frontend/src folder. The links to the official documentation of these packages is included in the Useful Links section.

  • Nginx: This is the server for the Docker-Compose testing build. The default configuration in use can be found at the nginx/nginx.conf file.

  • PostgreSQL: This is the default configured database for this repository. A link to How to install/configure it for Linux/Windows/MacOS is included in the Useful Links section (This is only necessary for when not running with docker-compose). In addition, a link to How to change to MySQL in Django is included as well in the Useful Links section.

Install (Run) with Docker

  1. Clone the repo:

    git clone https://github.com/Ceci-Aguilera/react_django_boilerplate.git

  2. Copy a default setup of the environment variables for the project:

    cp example_env .env
cp django_backend/django_backend/settings/example_env django_backend/django_backend/settings/.env

  3. (optional) Edit the values in the previous copied files to create a custom config. Note that the one set by default should work just fine for development.

  4. Run Docker-Compose:

    docker-compose up -d --build

    Congratulations !!! The app should be up and running. To access the React frontend go to localhost:80, and to access the Django backend go to localhost:80/api. From now on, any call made to localhost:80/api will be redirected to Django while every other path (localhost:80/*) will lead to the React frontend, with localhost:80/admin being the only exception (localhost:80/admin is an special url path that redirects to the Django Admin). In other words, the urls localhost:80/api and localhost:80/admin are reserved for the Django backend, while any other url of the form localhost:80/* redirects to the React frontend.

  5. (optional) To create a super user:

       docker-compose run backend ./manage.py createsuperuser

Install without Docker

  1. Clone the repo:

    git clone https://github.com/Ceci-Aguilera/react_django_boilerplate.git

  2. Copy a default configuration of the environment variables for Django:

    cp django_backend/django_backend/settings/example_env django_backend/django_backend/settings/.env

  3. (optional) Edit the values in the previous file that was copied to create a custom config. Note that the one set by default should work just fine for development.

  4. Set up the database. In this case the one in use by default is PostgreSQL. Assuming that PostgreSQL is already installed in the OS, and that the needed configurations for PostgreSQL to run in the OS are done, create a database and an user using the credentials specified in the django_backend/django_backend/settings/.env file that was just created/edited. Note: To now how to install and configure PostgreSQL, see the Useful Links section of this documentation.

  5. Change the default settings.py file in use from docker to development. To do this, go to the file django_backend/django_backend/settings/__init__.py and modify the line

    from .docker import *

    to

    from .dev import *

  6. Create and activate a virtual environment (See the Useful Links section if not know how)

  7. Install the necessary dependencies

    cd django_backend
pip install -r requirements.txt

  8. Run Django:

    cd django_backend
python manage.py makemigrations
python manage.py migrate
python manage.py runserver

  9. To configure React, from the project root folder go to react_frontend and install the necessary dependencies:

    cd react_frontend
npm install

  10. (optional) Add django backend url as proxy. To do so go to react_frontend and edit the package.json, in the block before the "devDependencies" block add

    "proxy": "http://localhost:5000/",

    Now, that section in the package.json should look like the following:

            "development": [
        "last 1 chrome version",
        "last 1 firefox version",
        "last 1 safari version"
        ]
    },
    "proxy": "http://localhost:5000/",
    "devDependencies": {
        "@babel/node": "^7.16.8",
        "@babel/plugin-transform-react-jsx": "^7.17.3",
        "babel-cli": "^6.26.0",
        "babel-preset-es2015": "^6.24.1",
        "babel-preset-react": "^6.24.1",
        "babel-register": "^6.26.0"
    }

  11. Run React while inside the react_frontend folder:

    npm start

Congratulations !!! The app should be up and running. To access the React frontend go to localhost:3000, and to access the Django backend go to localhost:8000.

Structure for Docker-Compose Explained

This repository is divided into 3 main folders (not counting the .readme_assets as it contains only the images displayed in the Readme). These folders are:

  • django_backend: Has the Django project created with django-admin startproject.
  • react_frontend: Has the React project create with npx create-react-app.
  • nginx: Has the Dockerfile used in the docker-compose.yml file and the default config to run Django + React. When running the project locally without Docker this folder can be ignored.

Each project (Django and React as separate projects) is intended to be self contained, and so it can be separately tested without the need of docker-compose.

When running with Docker Compose, there are 4 images that are created: A Django backend Image, a React frontend Image, a Nginx Image, and a PostgreSQL Image. The Dockerfiles for Django, React, and Nginx can be found in their respective folders, i.e, the Django Dockerfile is inside the django_backend folder, and so on. The PostgreSQL image has no custom Dockerfile, instead it is pulled from the Docker Hub, and the environment variables for the docker-compose file can be found at the .env file in the project root folder. This repository does not include that file, instead it offers an example_env file that can be renamed to .env and it should work out of the box (the default environment variables set do not need to be modified).

Django Files and Folders of Interest

So far, there is no app created for Django, and so, the only important folder so far is the settings folder inside the django_backend/django_backend folder. This contains different settings.py files for different environment. For example, the dev.py file has the default settings to run in the development environment, while the docker.py file has the default settings to run when using docker-compose. All of these files has the base.py file as their parent file (the base.py file has the settings to be shared among the environments), and so they all should have

from .base import *

as their first line. To change between environments, go to the django_backend/django_backend/__init__.py file and edit its first line. By default it should be

from .docker import *

To change to the environment x, replace that line with

from .x import *

Next, the templates, static, and media folders have been created (and configured in the settings) to store the hml, css, ... files.

React Files and Folders of Interest

Aside from the package.json and the src/index.js files there are no other edited files in this folder.

The following structure is used by the owner of this repository when working on a React project, and it was taken from the Next js workflow:

    react_frontend
    |___ src 
          |____ components
          |____ pages
          |____ styles
          |____ assets

Contributing

Inputs and contributions to this project are appreciated. To make them as transparent and easy as possible, please follow this steps:

  • How to contribute:

    1. Fork the repo and create your branch from master
    2. Clone the project to your own machine
    3. Commit changes to your own branch
    4. Update documentation
    5. Push your work back up to your fork
    6. Submit a Pull request

    Don't:

    • Don't include any license information when submitting your code as this repository is MIT licensed, and so your submissions are understood to be under the same MIT License as well.

  • How to report a bug:

    1. Open a new Issue.
    2. Write a bug report with details, background, and when possible sample code. That's it!

Useful Links

PostgreSQL and other Databases

Docker

Django and DRF

React

Miscellaneous

About

Boilerplate for Django (Django Rest Framework) React (with React-Bootstrap for styling) Web Application. It uses Docker, Docker-Compose, Nginx, and PostgreSQL

License:MIT License

Languages

Language:Python 53.2%Language:JavaScript 14.9%Language:HTML 13.1%Language:Dockerfile 8.9%Language:CSS 7.1%Language:Shell 2.9%