---
# System prepended metadata

title: PID 1294

---

Here is a detailed step-by-step guide on how upload large files using tus node server, including code snippets and explanations.
1. Setting Up the Tus Node Server Container [2]:
First, create a Docker container for your Tus Node server. This server will handle the file upload process and store the files on the hard disk. Here's a simplified example of how to create a Tus Node server container:

    ```Dockerfile
    # Dockerfile for Tus Node server
    FROM node:14

    WORKDIR /app
    COPY package*.json ./
    RUN npm install
    COPY . .

    EXPOSE 1080

    CMD ["node", "app.js"]
    ```
   In this example, we're using Node.js for the Tus server. You should adapt it to your specific setup.
2. Setting Up the Aqueduct Dart Server:
Now, let's configure your Aqueduct Dart server to communicate with the Tus Node server for file uploads. Install the necessary dependencies for handling HTTP requests:
    ```yaml
    # pubspec.yaml for Aqueduct Dart server
    dependencies:
      aqueduct: ^4.0.0
      http: ^0.13.3
    ```
    Next, create a controller in your Aqueduct server to handle the file upload requests. Here's an example:
    
    ```dart
    // file_upload_controller.dart

    import 'dart:convert';
    import 'dart:io';

    import 'package:aqueduct/aqueduct.dart';
    import 'package:http/http.dart' as http;

    class FileUploadController extends ResourceController {
      @Operation.post()
      Future<Response> uploadFile() async {
        // Get the file from the request
        final body = await request.body.decode();

        // Send a POST request to the Tus Node server to create a new upload
        final tusResponse = await http.post('http://tus-node-server:1080/files/', body: body);

        if (tusResponse.statusCode == 201) {
          // File upload initiated successfully, return a response to the client
          return Response.ok({'message': 'File upload initiated'});
        } else {
          // Handle the error
          return Response.serverError();
        }
      }
    }
    ```
   In this code, we send a POST request to the Tus Node server to initiate the file upload when a client sends a file to the Aqueduct server.
3. Flutter Client-Side Code [1]:
On the Flutter client-side, you can use the `tus_client` package to upload files using the Tus protocol. Make sure to add the `tus_client` package to your `pubspec.yaml`:

    ```yaml
    dependencies:
      tus_client: ^2.0.0
    ```
    Here's an example of how to upload a file from your Flutter app:
    ```dart
    import 'package:flutter/material.dart';
    import 'package:tus_client/tus_client.dart';

    void main() => runApp(MyApp());

    class MyApp extends StatelessWidget {
      @override
      Widget build(BuildContext context) {
        return MaterialApp(
          home: MyHomePage(),
        );
      }
    }

    class MyHomePage extends StatelessWidget {
      final tusClient = TusClient('http://aqueduct-server/upload'); // Replace with your Aqueduct server URL

      Future<void> uploadFile() async {
        final file = File('path/to/your/file');

        final tusUpload = await tusClient.createUpload(file);

        // Start the upload
        await tusUpload.start();

        // Check the upload progress
        tusUpload.progressStream.listen((progress) {
          print('Upload progress: $progress');
        });

        // Wait for the upload to complete
        await tusUpload.complete();

        print('File uploaded successfully');
      }

      @override
      Widget build(BuildContext context) {
        return Scaffold(
          appBar: AppBar(
            title: Text('Tus File Upload'),
          ),
          body: Center(
            child: ElevatedButton(
              onPressed: uploadFile,
              child: Text('Upload File'),
            ),
          ),
        );
      }
    }
    ```
   This Flutter code sets up a simple UI with a button to trigger the file upload process using the `tus_client` package.
4. Docker Compose Configuration:
To ensure the Aqueduct server and Tus Node server containers can communicate, use Docker Compose to define the services and their networks. Here's a simplified `docker-compose.yml`:

    ```yaml
    version: '3'
    services:
      aqueduct-server:
        build:
          context: ./aqueduct-server
        ports:
          - "8080:8080"
        networks:
          - tus-network

      tus-node-server:
        build:
          context: ./tus-node-server
        ports:
          - "1080:1080"
        networks:
          - tus-network

    networks:
      tus-network:
    ```
   Make sure to adjust the `context` paths and ports according to your actual project structure and requirements.
5. Running the Services:
After setting up your containers and configuring your services, you can run them using `docker-compose up`.

Please note that this is a simplified example, and you may need to adapt it to your specific project requirements, security considerations, and production needs.