To create a full-stack web application using React and Django, follow these steps:

1. Set up the development environment

Install Python, Node.js, and PostgreSQL on your system if you haven't already.

2. Create a new Django project

Open a terminal and run the following commands to install Django and start a new project:

```
pip install django
django-admin startproject my_project
cd my_project
```

3. Set up the PostgreSQL database

Edit `my_project/settings.py` to configure the PostgreSQL database:

```python
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'my_database',
        'USER': 'my_user',
        'PASSWORD': 'my_password',
        'HOST': 'localhost',
        'PORT': '',
    }
}
```

Run the following command to install the required package for PostgreSQL:

```
pip install psycopg2-binary
```

4. Create a Django app

Run the following command to create a new Django app called "shop":

```
python manage.py startapp shop
```

5. Install Django REST framework

Run the following command to install the Django REST framework:

```
pip install djangorestframework
```

Add `'rest_framework'` to the `INSTALLED_APPS` list in `my_project/settings.py`.

6. Implement user authentication

In `shop/models.py`, create a custom user model that inherits from `AbstractUser`:

```python
from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    pass
```

Update `my_project/settings.py` to use the custom user model:

```python
AUTH_USER_MODEL = 'shop.CustomUser'
```

7. Create serializers and views for the API

In `shop/serializers.py`, create serializers for the product and order models:

```python
from rest_framework import serializers
from .models import Product, Order

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = '__all__'

class OrderSerializer(serializers.ModelSerializer):
    class Meta:
        model = Order
        fields = '__all__'
```

In `shop/views.py`, create views for the API:

```python
from rest_framework import generics
from .models import Product, Order
from .serializers import ProductSerializer, OrderSerializer

class ProductList(generics.ListCreateAPIView):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

class OrderList(generics.ListCreateAPIView):
    queryset = Order.objects.all()
    serializer_class = OrderSerializer
```

8. Set up URLs for the API

In `shop/urls.py`, set up the URL patterns for the API:

```python
from django.urls import path
from .views import ProductList, OrderList

urlpatterns = [
    path('products/', ProductList.as_view(), name='product-list'),
    path('orders/', OrderList.as_view(), name='order-list'),
]
```

Include the app's URLs in `my_project/urls.py`:

```python
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('shop.urls')),
]
```

9. Create a React app

Run the following commands to create a new React app and install required packages:

```
npx create-react-app my_react_app
cd my_react_app
npm install axios react-router-dom @material-ui/core @material-ui/icons
```

10. Implement the frontend

Create components for displaying products, handling user authentication, managing the shopping cart, and submitting orders.

Use Axios to fetch data from the Django API and update the state of your React components accordingly.

11. Deploy the application

Once you have implemented all the required features, deploy your Django and React applications to a web server.

For Django, consider using Gunicorn or uWSGI as an application server and Nginx for serving static files.

For React, use `npm run build` to create a production build of your app and serve it using a web server like Nginx or Apache.

That's it! You now have a full-stack web application using React and Django that displays products fetched from a remote API, allows users to add items to a shopping cart, view the total cost, and submit orders with user authentication and order history stored in a PostgreSQL database.
React와 Django를 사용하여 풀스택 웹 애플리케이션을 만들려면 다음 단계를 따르세요:

1. 개발 환경 설정

아직 설치하지 않은 경우 시스템에 Python, Node.js 및 PostgreSQL을 설치합니다.

2. 새 Django 프로젝트를 만듭니다.

터미널을 열고 다음 명령을 실행하여 Django를 설치하고 새 프로젝트를 시작합니다:

```
pip 설치 장고
django-admin 시작 프로젝트 내_프로젝트
cd my_project
```

3. PostgreSQL 데이터베이스 설정

my_project/settings.py`를 편집하여 PostgreSQL 데이터베이스를 구성합니다:

```python
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'my_database',
        'USER': 'my_user',
        'PASSWORD': 'my_password',
        'HOST': 'localhost',
        'PORT': '',
    }
}
```

다음 명령을 실행하여 PostgreSQL에 필요한 패키지를 설치합니다:

```
pip 설치 싸이코피그2-바이너리
```

4. 장고 앱 생성

다음 명령을 실행하여 "shop"이라는 새 장고 앱을 생성합니다:

```
파이썬 manage.py startapp shop
```

5. 장고 REST 프레임워크 설치

다음 명령어를 실행하여 Django REST 프레임워크를 설치합니다:

```
pip 설치 장고레스트프레임워크
```

my_project/settings.py`의 `INSTALLED_APPS` 목록에 `'rest_framework'`를 추가합니다.

6. 사용자 인증 구현하기

shop/models.py`에서 `AbstractUser`를 상속하는 사용자 지정 사용자 모델을 생성합니다:

``파이썬
에서 AbstractUser를 가져옵니다.

class CustomUser(AbstractUser):
    pass
```

사용자 정의 사용자 모델을 사용하도록 `my_project/settings.py`를 업데이트합니다:

```python
AUTH_USER_MODEL = 'shop.CustomUser'
```

7. API에 대한 직렬화기 및 뷰 만들기

shop/serializers.py`에서 제품 및 주문 모델에 대한 직렬화기를 생성합니다:

```python
에서 직렬화기를 가져옵니다.
.models에서 제품, 주문 가져오기

클래스 ProductSerializer(serializers.ModelSerializer):
    클래스 Meta:
        모델 = Product
        fields = '__all__'

OrderSerializer(serializers.ModelSerializer) 클래스:
    Meta 클래스:
        모델 = Order
        fields = '__all__'
```

shop/views.py`에서 API에 대한 뷰를 생성합니다:

```python
rest_framework에서 제네릭을 가져옵니다.
.models에서 제품, 주문 임포트
.serializers에서 ProductSerializer, OrderSerializer를 가져옵니다.

ProductList(generics.ListCreateAPIView) 클래스:
    쿼리셋 = Product.objects.all()
    serializer_class = ProductSerializer

OrderList(generics.ListCreateAPIView) 클래스:
    queryset = Order.objects.all()
    serializer_class = OrderSerializer
```

8. API용 URL 설정

shop/urls.py`에서 API의 URL 패턴을 설정합니다:

``python
에서 django.urls 가져오기 경로
.views에서 제품 목록, 주문 목록 가져오기

urlpatterns = [
    path('products/', ProductList.as_view(), name='product-list'),
    path('orders/', OrderList.as_view(), name='order-list'),
]
```

내_프로젝트/urls.py`에 앱의 URL을 포함합니다:

```python
에서 관리자를 가져옵니다.
에서 관리자 가져오기 경로에 다음을 포함합니다.

urlpatterns = [
    경로('admin/', admin.site.urls),
    경로('api/', include('shop.urls')),
]
```

9. React 앱 생성하기

다음 명령어를 실행하여 새로운 React 앱을 생성하고 필요한 패키지를 설치합니다:

```
npx create-react-app my_react_app
cd my_react_app
npm install axios react-router-dom @material-ui/core @material-ui/icons
```

10. 프론트엔드 구현하기

제품 표시, 사용자 인증 처리, 장바구니 관리, 주문 제출을 위한 컴포넌트를 생성합니다.

Axios를 사용하여 Django API에서 데이터를 가져오고 그에 따라 React 컴포넌트의 상태를 업데이트하세요.

11. 애플리케이션 배포

필요한 모든 기능을 구현했으면 Django 및 React 애플리케이션을 웹 서버에 배포하세요.

Django의 경우 애플리케이션 서버로 Gunicorn 또는 uWSGI를 사용하고 정적 파일 서비스를 위해 Nginx를 사용하는 것을 고려하세요.

React의 경우, `npm run build`를 사용하여 앱의 프로덕션 빌드를 생성하고 Nginx 또는 Apache와 같은 웹 서버를 사용하여 서비스하세요.

여기까지입니다! 이제 원격 API에서 가져온 제품을 표시하고, 사용자가 장바구니에 상품을 추가하고, 총 비용을 확인하고, 사용자 인증 및 주문 내역을 PostgreSQL 데이터베이스에 저장하여 주문을 제출할 수 있는 React와 Django를 사용하는 풀스택 웹 애플리케이션이 생겼습니다.