Bài 10.4: API Versioning & Documentation - Phần 4 - Advanced Documentation

**Series Navigation:** - [Bài 10.1: API Versioning](./010-api-versioning-documentation.md) - [Bài 10.2: OpenAPI & Swagger](./010-api-versioning-documentation-part2.md) - [Bài 10.3: drf-spectacular](./010-api-versioning-documentation-part3.md) - **Bài 10.4 (bài này): Advanced Documentation** 👈

Mục Tiêu Bài 10.4

Sau khi hoàn thành Bài 10.4 này, bạn sẽ:

✅ Generate comprehensive documentation
✅ Add code samples
✅ Document complex scenarios
✅ Use markdown in docs
✅ Host documentation
✅ Follow best practices

Advanced Schema Customization

Detailed Endpoint Documentation

# views.pyfrom drf_spectacular.utils import extend_schema, OpenApiExample, OpenApiParameterfrom rest_framework import viewsets class ArticleViewSet(viewsets.ModelViewSet):    queryset = Article.objects.all()    serializer_class = ArticleSerializer        @extend_schema(        operation_id='listArticles',        summary='List all articles',        description="""        # List Articles                Returns a paginated list of articles with optional filtering and search.                ## Filters        - **status**: Filter by publication status (draft, published, archived)        - **author**: Filter by author ID        - **category**: Filter by category slug        - **tags**: Filter by tag names (comma-separated)                ## Search        - Use `search` parameter to search in title and content        - Supports full-text search with PostgreSQL                ## Ordering        - Use `ordering` parameter to sort results        - Available fields: created_at, views, likes        - Prefix with `-` for descending order                ## Examples                Get published articles:        ```        GET /api/articles/?status=published        ```                Search articles:        ```        GET /api/articles/?search=django        ```                Sort by views (descending):        ```        GET /api/articles/?ordering=-views        ```        """,        parameters=[            OpenApiParameter(                name='status',                type=str,                enum=['draft', 'published', 'archived'],                description='Filter by publication status',            ),            OpenApiParameter(                name='author',                type=int,                description='Filter by author ID',            ),            OpenApiParameter(                name='search',                type=str,                description='Search in title and content',            ),            OpenApiParameter(                name='ordering',                type=str,                enum=['created_at', '-created_at', 'views', '-views', 'likes', '-likes'],                description='Order results by field',            ),        ],        responses={            200: OpenApiExample(                'Success',                value={                    'count': 100,                    'next': 'http://api.example.com/articles/?page=2',                    'previous': None,                    'results': [                        {                            'id': 1,                            'title': 'Getting Started with Django',                            'content': 'Django is a high-level...',                            'author': {                                'id': 5,                                'username': 'john',                                'email': 'john@example.com'                            },                            'status': 'published',                            'views': 1500,                            'likes': 42,                            'created_at': '2024-01-01T00:00:00Z'                        }                    ]                }            )        },        tags=['Articles'],    )    def list(self, request, *args, **kwargs):        """Get list of articles"""        return super().list(request, *args, **kwargs)

Multiple Request/Response Examples

@extend_schema(    operation_id='createArticle',    summary='Create new article',    description='Create a new article with title, content, and optional metadata.',    request=ArticleSerializer,    examples=[        OpenApiExample(            name='Basic Draft Article',            description='Create a basic draft article with minimal fields',            value={                'title': 'My First Article',                'content': 'This is my first article content.',                'status': 'draft'            },            request_only=True,        ),        OpenApiExample(            name='Published Article',            description='Create and immediately publish an article',            value={                'title': 'Advanced Django Patterns',                'content': 'Learn about advanced Django design patterns...',                'status': 'published',                'tags': ['django', 'python', 'web-development'],                'category': 'tutorials'            },            request_only=True,        ),        OpenApiExample(            name='Article with Metadata',            description='Create article with all metadata fields',            value={                'title': 'Complete Guide to Django REST Framework',                'content': 'This comprehensive guide covers...',                'status': 'published',                'tags': ['django', 'drf', 'api'],                'category': 'guides',                'featured': True,                'excerpt': 'Learn everything about DRF',                'cover_image': 'https://example.com/images/cover.jpg'            },            request_only=True,        ),    ],    responses={        201: OpenApiExample(            name='Created Article',            description='Successfully created article',            value={                'id': 1,                'title': 'My First Article',                'content': 'This is my first article content.',                'author': {                    'id': 5,                    'username': 'john',                    'email': 'john@example.com'                },                'status': 'draft',                'views': 0,                'likes': 0,                'created_at': '2024-01-01T00:00:00Z',                'updated_at': '2024-01-01T00:00:00Z'            },            response_only=True,        ),        400: OpenApiExample(            name='Validation Error',            description='Request validation failed',            value={                'title': ['This field is required.'],                'content': ['This field is required.']            },            response_only=True,        ),        401: OpenApiExample(            name='Unauthorized',            description='Authentication credentials were not provided',            value={                'detail': 'Authentication credentials were not provided.'            },            response_only=True,        ),    },    tags=['Articles'],)def create(self, request, *args, **kwargs):    """Create new article"""    return super().create(request, *args, **kwargs)

Code Samples in Documentation

Adding cURL Examples

from drf_spectacular.utils import extend_schema, OpenApiExample @extend_schema(    summary='Get article details',    description="""    # Get Article Details        Retrieve detailed information about a specific article.        ## cURL Example        ```bash    curl -X GET "https://api.example.com/api/articles/1/" \\      -H "Authorization: Bearer YOUR_TOKEN" \\      -H "Accept: application/json"    ```        ## Python Example        ```python    import requests        headers = {        'Authorization': 'Bearer YOUR_TOKEN',        'Accept': 'application/json',    }        response = requests.get(        'https://api.example.com/api/articles/1/',        headers=headers    )        if response.status_code == 200:        article = response.json()        print(f"Title: {article['title']}")    ```        ## JavaScript Example        ```javascript    const response = await fetch('https://api.example.com/api/articles/1/', {      method: 'GET',      headers: {        'Authorization': 'Bearer YOUR_TOKEN',        'Accept': 'application/json',      },    });        if (response.ok) {      const article = await response.json();      console.log(`Title: ${article.title}`);    }    ```    """,    responses={        200: ArticleSerializer,        404: 'Article not found',    },    tags=['Articles'],)def retrieve(self, request, *args, **kwargs):    """Get article by ID"""    return super().retrieve(request, *args, **kwargs)

Language-Specific Code Examples

# utils.pydef generate_code_examples(endpoint, method, body=None):    """Generate code examples for different languages"""        examples = {        'curl': f"""curl -X {method} "https://api.example.com{endpoint}" \\  -H "Authorization: Bearer YOUR_TOKEN" \\  -H "Content-Type: application/json"{f'  -d \\'{json.dumps(body, indent=2)}\\'' if body else ''}        """,                'python': f"""import requests headers = {{    'Authorization': 'Bearer YOUR_TOKEN',    'Content-Type': 'application/json',}} {'data = ' + json.dumps(body, indent=4) if body else ''} response = requests.{method.lower()}(    'https://api.example.com{endpoint}',    headers=headers{',    json=data' if body else ''}) print(response.json())        """,                'javascript': f"""const response = await fetch('https://api.example.com{endpoint}', {{  method: '{method}',  headers: {{    'Authorization': 'Bearer YOUR_TOKEN',    'Content-Type': 'application/json',  }},{f'''  body: JSON.stringify({json.dumps(body, indent=4)}),''' if body else ''}}}); const data = await response.json();console.log(data);        """,    }        return examples # views.py@extend_schema(    description=f"""    # Create Article        ## Code Examples        ### cURL    ```bash    {generate_code_examples('/api/articles/', 'POST', {'title': 'Test', 'content': 'Content'})['curl']}    ```        ### Python    ```python    {generate_code_examples('/api/articles/', 'POST', {'title': 'Test', 'content': 'Content'})['python']}    ```        ### JavaScript    ```javascript    {generate_code_examples('/api/articles/', 'POST', {'title': 'Test', 'content': 'Content'})['javascript']}    ```    """)def create(self, request, *args, **kwargs):    return super().create(request, *args, **kwargs)

Complex Scenarios Documentation

File Upload Documentation

from rest_framework.parsers import MultiPartParser, FormParserfrom drf_spectacular.utils import extend_schema, OpenApiParameter, OpenApiTypes class ArticleImageViewSet(viewsets.ModelViewSet):    parser_classes = [MultiPartParser, FormParser]        @extend_schema(        summary='Upload article image',        description="""        # Upload Article Image                Upload an image for an article. Supports JPEG, PNG, and GIF formats.                ## Request                This is a multipart/form-data request with the following fields:        - **image**: Image file (required)        - **caption**: Image caption (optional)        - **alt_text**: Alt text for accessibility (optional)                ## File Constraints        - Max file size: 5MB        - Allowed formats: JPEG, PNG, GIF        - Recommended dimensions: 1200x630px                ## cURL Example                ```bash        curl -X POST "https://api.example.com/api/articles/1/upload-image/" \\          -H "Authorization: Bearer YOUR_TOKEN" \\          -F "image=@/path/to/image.jpg" \\          -F "caption=Article cover image" \\          -F "alt_text=Django REST Framework tutorial"        ```                ## Python Example                ```python        import requests                headers = {            'Authorization': 'Bearer YOUR_TOKEN',        }                files = {            'image': open('/path/to/image.jpg', 'rb'),        }                data = {            'caption': 'Article cover image',            'alt_text': 'Django REST Framework tutorial',        }                response = requests.post(            'https://api.example.com/api/articles/1/upload-image/',            headers=headers,            files=files,            data=data        )                print(response.json())        ```        """,        request={            'multipart/form-data': {                'type': 'object',                'properties': {                    'image': {                        'type': 'string',                        'format': 'binary',                        'description': 'Image file'                    },                    'caption': {                        'type': 'string',                        'description': 'Image caption'                    },                    'alt_text': {                        'type': 'string',                        'description': 'Alt text for accessibility'                    }                },                'required': ['image']            }        },        responses={            200: OpenApiExample(                'Image Uploaded',                value={                    'id': 1,                    'url': 'https://example.com/media/articles/image.jpg',                    'caption': 'Article cover image',                    'alt_text': 'Django REST Framework tutorial',                    'size': 245678,                    'uploaded_at': '2024-01-01T00:00:00Z'                }            ),            400: 'Invalid file format or size',        },        tags=['Articles', 'Media'],    )    @action(detail=True, methods=['post'])    def upload_image(self, request, pk=None):        """Upload article image"""        # Implementation here        pass

Bulk Operations Documentation

@extend_schema(    summary='Bulk create articles',    description="""    # Bulk Create Articles        Create multiple articles in a single request.        ## Request Body        Send an array of article objects. Each object should have the same structure    as a single article creation request.        ## Limits    - Maximum 100 articles per request    - Request times out after 30 seconds        ## Example Request        ```json    [      {        "title": "First Article",        "content": "Content for first article",        "status": "draft"      },      {        "title": "Second Article",        "content": "Content for second article",        "status": "published"      }    ]    ```        ## Response        Returns an array of created articles with their IDs and status.        ## Error Handling        If any article fails validation:    - The entire operation rolls back    - No articles are created    - Returns validation errors for all failed articles    """,    request=ArticleSerializer(many=True),    examples=[        OpenApiExample(            'Bulk Create',            value=[                {                    'title': 'Article 1',                    'content': 'Content 1',                    'status': 'draft'                },                {                    'title': 'Article 2',                    'content': 'Content 2',                    'status': 'published'                },            ],            request_only=True,        ),    ],    responses={        201: OpenApiExample(            'Articles Created',            value={                'created': 2,                'articles': [                    {'id': 1, 'title': 'Article 1', 'status': 'draft'},                    {'id': 2, 'title': 'Article 2', 'status': 'published'},                ]            }        ),        400: OpenApiExample(            'Validation Error',            value={                'errors': [                    {'index': 0, 'title': ['This field is required.']},                    {'index': 1, 'content': ['This field is required.']},                ]            }        ),    },    tags=['Articles', 'Bulk Operations'],)@action(detail=False, methods=['post'])def bulk_create(self, request):    """Bulk create articles"""    # Implementation here    pass

Webhook Documentation

@extend_schema(    summary='Register webhook',    description="""    # Register Webhook        Register a webhook to receive real-time notifications when articles are created,    updated, or deleted.        ## Webhook Events        - `article.created`: Triggered when a new article is created    - `article.updated`: Triggered when an article is updated    - `article.deleted`: Triggered when an article is deleted    - `article.published`: Triggered when an article is published        ## Webhook Payload        Your endpoint will receive POST requests with the following structure:        ```json    {      "event": "article.created",      "timestamp": "2024-01-01T00:00:00Z",      "data": {        "id": 1,        "title": "Article Title",        "status": "published",        "author": {          "id": 5,          "username": "john"        }      }    }    ```        ## Webhook Security        Each webhook request includes a signature in the `X-Webhook-Signature` header.    Verify this signature to ensure the request came from our server:        ```python    import hmac    import hashlib        def verify_webhook(request, secret):        signature = request.headers.get('X-Webhook-Signature')        body = request.body.decode('utf-8')                expected = hmac.new(            secret.encode('utf-8'),            body.encode('utf-8'),            hashlib.sha256        ).hexdigest()                return hmac.compare_digest(signature, expected)    ```        ## Retry Policy        - Failed webhooks are retried 3 times    - Exponential backoff: 1min, 5min, 15min    - Webhooks are disabled after 10 consecutive failures    """,    request={        'application/json': {            'type': 'object',            'properties': {                'url': {                    'type': 'string',                    'format': 'uri',                    'description': 'Webhook URL (must be HTTPS)'                },                'events': {                    'type': 'array',                    'items': {                        'type': 'string',                        'enum': ['article.created', 'article.updated', 'article.deleted', 'article.published']                    },                    'description': 'Events to subscribe to'                },                'secret': {                    'type': 'string',                    'description': 'Secret for webhook signature verification'                }            },            'required': ['url', 'events']        }    },    responses={        201: OpenApiExample(            'Webhook Created',            value={                'id': 'wh_abc123',                'url': 'https://example.com/webhook',                'events': ['article.created', 'article.published'],                'active': True,                'created_at': '2024-01-01T00:00:00Z'            }        ),    },    tags=['Webhooks'],)@action(detail=False, methods=['post'])def register_webhook(self, request):    """Register webhook"""    # Implementation here    pass

Pagination Documentation

from drf_spectacular.utils import extend_schema, OpenApiExample @extend_schema(    description="""    # Pagination        All list endpoints support pagination. By default, results are paginated with    20 items per page.        ## Pagination Parameters        - `page`: Page number (default: 1)    - `page_size`: Items per page (default: 20, max: 100)        ## Response Format        Paginated responses include:    - `count`: Total number of items    - `next`: URL to next page (null if last page)    - `previous`: URL to previous page (null if first page)    - `results`: Array of items for current page        ## Examples        Get first page:    ```    GET /api/articles/    ```        Get specific page:    ```    GET /api/articles/?page=2    ```        Custom page size:    ```    GET /api/articles/?page=1&page_size=50    ```    """,    responses={        200: OpenApiExample(            'Paginated Response',            value={                'count': 100,                'next': 'http://api.example.com/articles/?page=2',                'previous': None,                'results': [                    {                        'id': 1,                        'title': 'Article Title',                        'status': 'published'                    }                ]            }        )    },)def list(self, request, *args, **kwargs):    return super().list(request, *args, **kwargs)

Error Response Documentation

Standard Error Responses

# utils.pyfrom drf_spectacular.utils import OpenApiExample ERROR_RESPONSES = {    400: OpenApiExample(        'Bad Request',        description='Request validation failed',        value={            'error': 'Validation error',            'details': {                'field_name': ['Error message']            }        }    ),    401: OpenApiExample(        'Unauthorized',        description='Authentication required',        value={            'detail': 'Authentication credentials were not provided.'        }    ),    403: OpenApiExample(        'Forbidden',        description='Insufficient permissions',        value={            'detail': 'You do not have permission to perform this action.'        }    ),    404: OpenApiExample(        'Not Found',        description='Resource not found',        value={            'detail': 'Not found.'        }    ),    429: OpenApiExample(        'Rate Limit Exceeded',        description='Too many requests',        value={            'detail': 'Request was throttled. Expected available in 60 seconds.'        }    ),    500: OpenApiExample(        'Internal Server Error',        description='Server error',        value={            'detail': 'Internal server error.'        }    ),} # views.py@extend_schema(    responses={        200: ArticleSerializer,        **ERROR_RESPONSES    },)def retrieve(self, request, *args, **kwargs):    return super().retrieve(request, *args, **kwargs)

Authentication Documentation

# settings.pySPECTACULAR_SETTINGS = {    'TITLE': 'My API',    'VERSION': '1.0.0',    'DESCRIPTION': """    # Authentication        This API uses JWT (JSON Web Token) authentication.        ## Getting a Token        Send your credentials to the token endpoint:        ```bash    curl -X POST "https://api.example.com/api/token/" \\      -H "Content-Type: application/json" \\      -d '{"username": "your_username", "password": "your_password"}'    ```        Response:    ```json    {      "access": "eyJ0eXAiOiJKV1QiLCJhbGc...",      "refresh": "eyJ0eXAiOiJKV1QiLCJhbGc..."    }    ```        ## Using the Token        Include the access token in the Authorization header:        ```bash    curl -X GET "https://api.example.com/api/articles/" \\      -H "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGc..."    ```        ## Token Expiration        - Access tokens expire after 5 minutes    - Refresh tokens expire after 24 hours    - Use the refresh token to get a new access token        ## Refreshing Tokens        ```bash    curl -X POST "https://api.example.com/api/token/refresh/" \\      -H "Content-Type: application/json" \\      -d '{"refresh": "eyJ0eXAiOiJKV1QiLCJhbGc..."}'    ```    """,    'SECURITY': [{'bearerAuth': []}],    'APPEND_COMPONENTS': {        'securitySchemes': {            'bearerAuth': {                'type': 'http',                'scheme': 'bearer',                'bearerFormat': 'JWT',                'description': 'JWT authentication. Format: `Bearer <token>`'            }        }    },}

Rate Limiting Documentation

@extend_schema(    description="""    # Rate Limiting        API requests are rate limited to prevent abuse.        ## Limits        - **Authenticated users**: 1000 requests per hour    - **Anonymous users**: 100 requests per hour        ## Response Headers        Rate limit information is included in response headers:        - `X-RateLimit-Limit`: Maximum requests allowed    - `X-RateLimit-Remaining`: Remaining requests    - `X-RateLimit-Reset`: Unix timestamp when limit resets        ## Example        ```http    HTTP/1.1 200 OK    X-RateLimit-Limit: 1000    X-RateLimit-Remaining: 999    X-RateLimit-Reset: 1640995200    ```        ## Rate Limit Exceeded        When you exceed the rate limit, you'll receive a 429 response:        ```json    {      "detail": "Request was throttled. Expected available in 3600 seconds."    }    ```    """,)def list(self, request, *args, **kwargs):    return super().list(request, *args, **kwargs)

Hosting Documentation

Static Documentation

# Generate static OpenAPI schemapython manage.py spectacular --file openapi.yaml # Generate HTML documentation with ReDocnpx @redocly/cli build-docs openapi.yaml --output docs/index.html # Serve static docspython -m http.server 8080 --directory docs/

Netlify Deployment

# netlify.toml[build]  command = "python manage.py spectacular --file openapi.yaml && npx @redocly/cli build-docs openapi.yaml --output public/index.html"  publish = "public" [[redirects]]  from = "/*"  to = "/index.html"  status = 200

GitHub Pages

# .github/workflows/docs.ymlname: Deploy Documentation on:  push:    branches: [main] jobs:  deploy:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v2            - name: Setup Python        uses: actions/setup-python@v2        with:          python-version: '3.10'            - name: Install dependencies        run: |          pip install -r requirements.txt            - name: Generate OpenAPI schema        run: |          python manage.py spectacular --file openapi.yaml            - name: Build ReDoc documentation        run: |          npx @redocly/cli build-docs openapi.yaml --output docs/index.html            - name: Deploy to GitHub Pages        uses: peaceiris/actions-gh-pages@v3        with:          github_token: ${{ secrets.GITHUB_TOKEN }}          publish_dir: ./docs

Documentation Best Practices

1. Write Clear Descriptions

@extend_schema(    summary='Short, action-oriented summary',  # Good: "Create article"    description="""    # Longer Description        Provide more context here. Explain:    - What the endpoint does    - When to use it    - Important considerations    """,)

2. Include Examples

@extend_schema(    examples=[        OpenApiExample(            name='Common Use Case',            description='Explanation of this example',            value={'field': 'value'},        ),        OpenApiExample(            name='Edge Case',            description='Less common but important example',            value={'field': 'special_value'},        ),    ],)

3. Document All Error Cases

@extend_schema(    responses={        200: SuccessSerializer,        400: 'Validation error - explain what causes this',        401: 'Not authenticated - explain auth requirement',        403: 'Permission denied - explain required permissions',        404: 'Not found - explain what resource',        429: 'Rate limited - explain limits',    },)

4. Use Tags for Organization

@extend_schema(    tags=['Articles', 'CRUD'],  # Multiple tags for better organization)

5. Document Field Constraints

class ArticleSerializer(serializers.ModelSerializer):    title = serializers.CharField(        max_length=200,        help_text='Article title (max 200 characters, required)',    )    content = serializers.CharField(        min_length=100,        help_text='Article content in Markdown (min 100 characters)',    )

6. Keep Documentation Up-to-Date

# Use pre-commit hooks to validate schema# .pre-commit-config.yamlrepos:  - repo: local    hooks:      - id: validate-openapi-schema        name: Validate OpenAPI Schema        entry: python manage.py spectacular --validate        language: system        pass_filenames: false

7. Version Your Documentation

# urls.pyurlpatterns = [    path('api/v1/schema/', SpectacularAPIView.as_view(), name='schema-v1'),    path('api/v2/schema/', SpectacularAPIView.as_view(), name='schema-v2'),        path('api/v1/docs/', SpectacularSwaggerView.as_view(url_name='schema-v1'), name='docs-v1'),    path('api/v2/docs/', SpectacularSwaggerView.as_view(url_name='schema-v2'), name='docs-v2'),]

Complete Example: Production-Ready Documentation

# settings.pySPECTACULAR_SETTINGS = {    'TITLE': 'Article API',    'DESCRIPTION': """    # Article Management API        Production-ready API for managing articles, users, and comments.        ## Features    - Full CRUD operations    - Advanced filtering and search    - File uploads    - Bulk operations    - Webhook notifications    - Rate limiting        ## Authentication    Uses JWT authentication. See /api/token/ for obtaining tokens.        ## Rate Limits    - Authenticated: 1000 req/hour    - Anonymous: 100 req/hour        ## Support    - Email: support@example.com    - Docs: https://docs.example.com    - Status: https://status.example.com    """,    'VERSION': '2.0.0',    'CONTACT': {        'name': 'API Support',        'email': 'support@example.com',        'url': 'https://www.example.com/support',    },    'LICENSE': {        'name': 'MIT License',        'url': 'https://opensource.org/licenses/MIT',    },    'SERVERS': [        {'url': 'https://api.example.com', 'description': 'Production'},        {'url': 'https://staging-api.example.com', 'description': 'Staging'},        {'url': 'http://localhost:8000', 'description': 'Development'},    ],    'EXTERNAL_DOCS': {        'description': 'Full Documentation',        'url': 'https://docs.example.com',    },    'TAGS': [        {'name': 'Articles', 'description': 'Article management'},        {'name': 'Users', 'description': 'User management'},        {'name': 'Comments', 'description': 'Comment management'},        {'name': 'Media', 'description': 'File uploads'},        {'name': 'Webhooks', 'description': 'Webhook management'},    ],    'SECURITY': [{'bearerAuth': []}],    'COMPONENT_SPLIT_REQUEST': True,    'SCHEMA_PATH_PREFIX': '/api/',}

Tóm Tắt Bài 10.4

Trong Bài 10.4 này, bạn đã học:

✅ Advanced Schema Customization:

Detailed endpoint documentation
Multiple request/response examples
Comprehensive descriptions

✅ Code Samples:

cURL examples
Python examples
JavaScript examples
Language-specific code generation

✅ Complex Scenarios:

File upload documentation
Bulk operations
Webhooks
Pagination
Error responses

✅ Documentation Deployment:

Static documentation generation
Netlify deployment
GitHub Pages deployment
CI/CD integration

✅ Best Practices:

Clear descriptions
Comprehensive examples
Error documentation
Field constraints
Version control
Keep docs updated

Series Summary: API Versioning & Documentation

Congratulations! Bạn đã hoàn thành series về API Versioning và Documentation.

Bài 10.1 - API Versioning strategies
Bài 10.2 - OpenAPI & Swagger basics
Bài 10.3 - drf-spectacular advanced features
Bài 10.4 - Advanced documentation techniques

Next Steps

Bài 11: Testing trong Django REST Framework

Unit testing
Integration testing
API testing with pytest
Test coverage
Mocking and fixtures

Navigation:

← Bài 10.3: drf-spectacular
Bài 10.4: Advanced Documentation (current)
Bài 11: Testing in DRF →

#api-documentation

API Versioning & Documentation - Phần 4 - Advanced Documentation