## Introduction In the digital era, video is the king, demanding innovative solutions for efficient processing and distribution. This guide introduces a powerful approach using Koyeb's cloud services to build a scalable video processing pipeline. We will rely on secure protocols for video uploads, employ AI-driven tagging and classification via AssemblyAI, and leverage Koyeb's built-in CDN technology for global content distribution. Embrace the power of serverless architecture to meet the growing demand for video content, ensuring optimal performance and viewer satisfaction. You can follow along with this guide by viewing the GitHub repositories for the [video web app](https://github.com/koyeb/example-video-processing-app) and the [video worker service](https://github.com/koyeb/example-video-processing-worker). ## Requirements Before diving into building your video processing pipeline with Koyeb, it's important to ensure that you have the necessary tools and knowledge. This section outlines the prerequisites needed to follow the upcoming guide successfully. - A [Koyeb account](https://app.koyeb.com/auth/signup) will be required for deploying. It will be helpful to have a foundational understanding of its service offerings (web service and database, in this case). - An [AssemblyAI API key](https://www.assemblyai.com/dashboard/signup) to integrate AI-driven video tagging and classification capabilities. **Note:** You will need to add credit to your account to use the LLM features implemented in this guide. - Knowledge of Python programming for scripting and automation within the serverless architecture. - Experience with Django for developing robust, scalable web applications that interfaces effectively with back-end services. ## Steps 1. [Set up the database](#set-up-the-database): This step involves setting up a database service on Koyeb to store and manage video metadata. This database will be used by the web application to store and access data. 2. [Build the web application](#build-the-web-application): This section guides you through developing a simple web application for video uploads along with features to view and search videos. The application is built with Django. 3. [Build the worker service](#build-the-worker-service): This step covers implementing a service API that processes the video uploads. The API will incorporate AI technologies from AssemblyAI for tagging, classifying, and potentially transcoding videos. Additionally, the API will utilize Koyeb's autoscaling features to efficiently manage varying video processing loads. 4. [Integrate with Koyeb's edge network](#integrate-with-koyebs-edge-network): This section details how to integrate the web application with Koyeb's edge network to enhance the distribution of video content globally. ## Set up the database Setting up the database is an important part of this process. This database will be used to keep and organize video metadata, such as video titles, descriptions, lengths, file types, and other important information. For this article you are going to setup a PostgreSQL database using Koyeb's recent fully-managed serverless PostgreSQL databases feature. Here's a step-by-step guide on how to set up the database on Koyeb: 1. In the [Koyeb control panel](https://app.koyeb.com/), click **Create Database Service**. 2. Choose alternatives to or confirm the provided defaults for the name and role fields. 3. Choose the region closest to you or your users. 4. Select the database size. If you are not already using it, you can deploy the **Free** tire as the Instance type. 5. Click **Create Database Service**. Once the database is created, access the database's detail page and there you can check the connection details. Since you will be using Django later, select **Django** and copy the database connection details. Store this locally somewhere so that you can reference it later. It will look like something like this: ```python DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql', 'NAME': 'koyebdb', 'USER': 'koyeb-adm', 'PASSWORD': , 'HOST': '.eu-central-1.pg.koyeb.app', 'OPTIONS': {'sslmode': 'require'}, } } ``` Once you've completed these steps, your database will be ready to store and manage video metadata for your application. ## Build the web application This part of the guide will show you how to make a simple web application using Django and deploy it to Koyeb. This app will let users upload videos and also provide features to watch for these uploaded videos. The focus of this article is the end-to-end process, so in this section we will only highlight the code relevant to this process. You can check the full source code in the [project's GitHub repository](https://github.com/koyeb/example-video-processing-pipeline). ### Create a virtual environment and initialize a new project To get started, create a project directory and then initialize a new virtual environment inside by typing: ```bash mkdir example-video-app cd example-video-app python3 -m venv venv ``` Activate the new virtual environment by typing: ```bash source venv/bin/activate ``` Install Django within the virtual environment. We'll also install some additional libraries and packages that we'll use in the application while we're here: ```bash pip install Django requests python-decouple psycopg2-binary Pillow ``` Save the project's dependencies to a `requirements.txt` file by typing: ```bash pip freeze > requirements.txt ``` With Django installed, create a new Django project called **VideoApp** rooted in the existing project directory (be sure to include the trailing dot to avoid creating an extra directory hierarchy): ```bash django-admin startproject VideoApp . ``` Next, create a new Django application called **App** that the project will incorporate: ```bash python manage.py startapp App ``` This will create a new `App` directory alongside the existing `VideoApp` directory. ### Set up the app models In the `App/models.py` file, you can now define the Django models for the video metadata. Replace the current contents with the following: ```python # File: App/models.py from django.db import models # Model to store video metadata class Video(models.Model): title = models.CharField(max_length=100) description = models.TextField() video_file = models.FileField(upload_to='videos/') uploaded_at = models.DateTimeField(auto_now_add=True) duration = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True) size = models.CharField(max_length=10, null=True, blank=True) def __str__(self): return self.title # Model to store video related tags class Tag(models.Model): name = models.CharField(max_length=50) video = models.ManyToManyField(Video, related_name='tags') def __str__(self): return self.name # Model to store video classification class Category(models.Model): name = models.CharField(max_length=50) video = models.ManyToManyField(Video, related_name='categories') def __str__(self): return self.name ``` Here you are defining three database models: `Video`, `Tag`, and `Category`. The `Video` model is used to store video metadata, including the title, description, video file, upload date and time, duration, and size. The `Tag` model is used to store video-related tags. It has a many-to-many relationship with the `Video` model, meaning that a video can have multiple tags and a tag can be associated with multiple videos. The `related_name` attribute specifies the name of the reverse relation from the `Video` model back to the `Tag` model. The `Category` model is used to store video classifications. It also has a many-to-many relationship with the `Video` model, meaning that a video can belong to multiple categories and a category can contain multiple videos. The `related_name` attribute specifies the name of the reverse relation from the `Video` model back to the `Category` model. ## Create a video upload form In order to be able to upload any videos, you need to have a form defined in Django, let's now create that in `App/forms.py`: ```python # File: App/forms.py from django import forms from .models import Video, Tag, Category # Form for video upload class VideoForm(forms.ModelForm): class Meta: model = Video fields = ['title', 'description', 'video_file'] ``` The `VideoForm` is a `ModelForm`, a special form created from a Django model. In this case, the `Video` model is used. The `Meta` class inside `VideoForm` is used to specify additional metadata for the form. The `model` attribute indicates which Django model this form is associated with, and the `fields` attribute is a list of model fields that should be included in the form. In this case, the form includes fields for `title`, `description`, `video_file`. The `tags` and `categories`, as well as `duration` and `size` will be filled in later on with the results from the worker service API. This form will allow users to input data for these fields, which will then be saved as a new `Video` object in the database when the form is submitted. ### Configure the App views With the form in place, next you can create the view that will handle the form submission. Replace the contents of `App/views.py` with the following: ```python # File: App/views.py import requests from decouple import config from django.shortcuts import render from App.forms import VideoForm from App.models import Tag, Category, Video # View to handle video upload from the video upload form def upload_video(request): form = VideoForm() if request.method == 'POST': form = VideoForm(request.POST, request.FILES) if form.is_valid(): # Save the video form.save() # Process the video file with the worker video_url = config("DOMAIN") + form.instance.video_file.url worker_url = config("WORKER_URL") + "/process_video?video_url=" + video_url # Send a GET request to the worker URL response = requests.get(worker_url) if response.status_code == 200: # Get the response data response_data = response.json() # Save the video tags tags = response_data.get('tags') for tag in tags: tag, created = Tag.objects.get_or_create(name=tag) form.instance.tags.add(tag) # Save the video categories categories = response_data.get('categories') for category in categories: category, created = Category.objects.get_or_create(name=category) form.instance.categories.add(category) # Save the video duration and resolution form.instance.duration = response_data.get('duration') form.instance.size = response_data.get('resolution') form.instance.save() # Return a success message return render(request, 'upload_video.html', {'form': form, 'message': 'Video uploaded successfully!'}) else: # Return the form with errors return render(request, 'upload_video.html', {'form': form, 'message': 'Error uploading video!'}) return render(request, 'upload_video.html', {'form': form}) def list_videos(request): videos = Video.objects.all() return render(request, 'list_videos.html', {'videos': videos}) ``` The `upload_video` view function handles the video upload process. When a user submits the video upload form, this function is called to process the form data. It starts by creating an instance of the `VideoForm` with the form data and files. If the form is valid, it saves the video, processes the video file with a worker service, and saves the video metadata (tags, categories, duration, and resolution) returned by the worker service API. If the form is not valid, it returns the form with errors. If the request method is not POST, it simply renders the video upload form. The `list_videos` view function retrieves all videos from the database and renders them in a template. ### Create the application templates In order for this view to work, you will need to create the HTML template. Create a new directory for HTML templates: ```bash mkdir App/templates ``` Inside, create a new file at `App/templates/upload_video.html` with the following content: ```html Video App

Video App

Back to Video list

Upload your video

{{ message }} ``` This HTML markup creates a simple web page for uploading videos. The video upload form is created using the HTML `

` tag. The `method` attribute is set to `post`, which means the form data will be sent to the server using the HTTP `POST` method. The `enctype` attribute is set to "multipart/form-data", which is necessary for forms that allow file uploads. The `{% csrf_token %}` template tag is used to protect against cross-site request forgery attacks. When the form is submitted, the data is sent to the server and handled by the `upload_video` view function in the `views.py` file. As mentioned earlier, if the form is valid, the video is saved and processed by the worker service, and a success message is displayed. If the form is not valid, an error message is displayed. You will also need an HTML template to list the videos. Add the following to a `App/templates/list_videos.html` file: ```html Video App

Video App

Upload New Video

{% for video in videos %}

Description: {{ video.description }}

Tags: {% for tag in video.tags.all %} {{ tag.name }}, {% endfor %}

Categories: {% for category in video.categories.all %} {{ category.name }}, {% endfor %}

Duration: {{ video.duration }} seconds

Resolution: {{ video.size }}

-----

{% endfor %} ``` The `{% for video in videos %}` template tag is used to loop through the list of videos passed from the `list_videos` view function in the `views.py` file. For each video, it displays the video player, title, description, tags, categories, duration, and resolution. The `

Video App

Upload your video

Video App

{{ video.title }}

CDN

Build a Video Processing Pipeline with AssemblyAI on Koyeb