Function Compute:Praktik terbaik untuk pemrosesan audio dan video

Tanpa akselerasi GPU

Output tunggal (1:1)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -i input.mp4 -c:v h264 -vf scale=1920:1080 -b:v 5M output.mp4

Output ganda (1:N)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -i input.mp4 \
  -c:a copy -c:v h264 -vf scale=1920:1080 -b:v 5M output_1080.mp4 \
  -c:a copy -c:v h264 -vf scale=1280:720  -b:v 5M output_720.mp4 \
  -c:a copy -c:v h264 -vf scale=640:480   -b:v 5M output_480.mp4

Dengan akselerasi GPU

Output tunggal (1:1)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -hwaccel cuda -hwaccel_output_format cuda \
  -i input.mp4 -c:v h264_nvenc -vf scale_cuda=1920:1080:1:4 -b:v 5M output.mp4

Output ganda (1:N)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -hwaccel cuda -hwaccel_output_format cuda -i input.mp4 \
  -c:a copy -c:v h264_nvenc -vf scale_npp=1920:1080 -b:v 5M output_1080.mp4 \
  -c:a copy -c:v h264_nvenc -vf scale_npp=1280:720  -b:v 5M output_720.mp4 \
  -c:a copy -c:v h264_nvenc -vf scale_npp=640:480   -b:v 5M output_480.mp4

Parameter utama

Prosedur

1. Buat proyek.

   fc-gpu-prj
   ├── code
   │   ├── app.py        # Kode fungsi
   │   └── Dockerfile    # Dockerfile gambar
   ├── README.md
   └── s.yaml            # Konfigurasi penyebaran

   Struktur proyek yang dihasilkan:

   fc-gpu-prj
   ├── code
   │   ├── app.py        # Kode fungsi
   │   └── Dockerfile    # Dockerfile gambar
   ├── README.md
   └── s.yaml            # Konfigurasi penyebaran

2. Masuk ke direktori proyek.

   cd fc-gpu-prj

3. Edit file konfigurasi. s.yaml — perbarui wilayah, nama layanan, dan URI gambar kontainer sesuai lingkungan Anda. Parameter utama terkait GPU adalah instanceType: fc.gpu.tesla.1 dan gpuMemorySize: 8192.

   edition: 1.0.0
   name: container-demo
   access: default
   vars:
     region: cn-shenzhen
   services:
     customContainer-demo:
       component: devsapp/fc
       props:
         region: ${vars.region}
         service:
           name: tgpu_ffmpeg_service
           internetAccess: true
         function:
           name: tgpu_ffmpeg_func
           description: test gpu for ffmpeg
           handler: not-used
           timeout: 600
           caPort: 9000
           instanceType: fc.gpu.tesla.1
           gpuMemorySize: 8192
           cpu: 4
           memorySize: 16384
           diskSize: 512
           runtime: custom-container
           customContainerConfig:
             # Prasyarat:
             # 1. Buat namespace "demo" dan repository "gpu-transcoding_s" di Container Registry.
             # 2. Tingkatkan tag (misalnya, v0.1 -> v0.2) saat memperbarui dan menyebarkan ulang.
             image: registry.cn-shanghai.aliyuncs.com/demo/gpu-transcoding_s:v0.1
           codeUri: ./code

   Untuk daftar lengkap parameter YAML, lihat Spesifikasi YAML. app.py — fungsi ini mengunduh video sumber dari OSS, mentranskode dengan FFmpeg (menggunakan GPU atau CPU berdasarkan header TRANS-MODE), lalu mengunggah hasilnya kembali ke OSS. Ganti nilai placeholder src_url dan dst_url dengan URL objek OSS aktual Anda.

   # -*- coding: utf-8 -*-
   from __future__ import print_function
   from http.server import HTTPServer, BaseHTTPRequestHandler
   import json
   import sys
   import logging
   import os
   import time
   import urllib.request
   import subprocess
   
   class Resquest(BaseHTTPRequestHandler):
       def download(self, url, path):
           print("enter download:", url)
           f = urllib.request.urlopen(url)
           with open(path, "wb") as local_file:
               local_file.write(f.read())
   
       def upload(self, url, path):
           print("enter upload:", url)
           headers = {
               'Content-Type': 'application/octet-stream',
               'Content-Length': os.stat(path).st_size,
           }
           req = urllib.request.Request(url, open(path, 'rb'), headers=headers, method='PUT')
           urllib.request.urlopen(req)
   
       def trans(self, input_path, output_path, enable_gpu):
           print("enter trans input:", input_path, " output:", output_path, " enable_gpu:", enable_gpu)
   
           cmd = ['ffmpeg', '-y', '-i', input_path, "-c:a", "copy", "-c:v", "h264", "-b:v", "5M", output_path]
           if enable_gpu:
               cmd = ["ffmpeg", "-y", "-hwaccel", "cuda", "-hwaccel_output_format", "cuda", "-i", input_path, "-c:v", "h264_nvenc", "-b:v", "5M", output_path]
   
           try:
               subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
           except subprocess.CalledProcessError as exc:
               print('\nreturncode:{}'.format(exc.returncode))
               print('\ncmd:{}'.format(exc.cmd))
               print('\noutput:{}'.format(exc.output))
               print('\nstderr:{}'.format(exc.stderr))
               print('\nstdout:{}'.format(exc.stdout))
   
       def trans_wrapper(self, enable_gpu):
           src_url = "https://your.domain/input.mp4"  # Ganti dengan URL objek OSS Anda (akses baca diperlukan)
           dst_url = "https://your.domain/output.flv" # Ganti dengan URL objek OSS Anda (akses tulis diperlukan)
           src_path = "/tmp/input_c.flv"
           dst_path = "/tmp/output_c.mp4"
   
           if enable_gpu:
               src_url = "https://your.domain/input.mp4"  # Ganti dengan URL objek OSS Anda (akses baca diperlukan)
               dst_url = "https://your.domain/output.flv" # Ganti dengan URL objek OSS Anda (akses tulis diperlukan)
               src_path = "/tmp/input_g.flv"
               dst_path = "/tmp/output_g.mp4"
   
           local_time = time.time()
           self.download(src_url, src_path)
           download_time = time.time() - local_time
   
           local_time = time.time()
           self.trans(src_path, dst_path, enable_gpu)
           trans_time = time.time() - local_time
   
           local_time = time.time()
           self.upload(dst_url, dst_path)
           upload_time = time.time() - local_time
   
           data = {'result':'ok', 'download_time':download_time, 'trans_time':trans_time, 'upload_time':upload_time}
           self.send_response(200)
           self.send_header('Content-type', 'application/json')
           self.end_headers()
           self.wfile.write(json.dumps(data).encode())
   
       def pong(self):
           data = {"function":"trans_gpu"}
           self.send_response(200)
           self.send_header('Content-type', 'application/json')
           self.end_headers()
           self.wfile.write(json.dumps(data).encode())
   
       def dispatch(self):
           mode = self.headers.get('TRANS-MODE')
   
           if mode == "ping":
               self.pong()
           elif mode == "gpu":
               self.trans_wrapper(True)
           elif mode == "cpu":
               self.trans_wrapper(False)
           else:
               self.pong()
   
       def do_GET(self):
           self.dispatch()
   
       def do_POST(self):
           self.dispatch()
   
   if __name__ == '__main__':
       host = ('0.0.0.0', 9000)
       server = HTTPServer(host, Resquest)
       print("Starting server, listen at: %s:%s" % host)
       server.serve_forever()

   Dockerfile — membangun gambar kontainer dari gambar dasar NVIDIA FFmpeg dan menambahkan runtime Python.

   FROM registry.cn-shanghai.aliyuncs.com/serverless_devs/nvidia-ffmpeg:latest
   WORKDIR /usr/src/app
   RUN apt-get update --fix-missing
   RUN apt-get install -y python3
   RUN apt-get install -y python3-pip
   COPY . .
   ENTRYPOINT [ "python3", "-u", "/usr/src/app/app.py" ]
   EXPOSE 9000

4. Bangun gambar kontainer.

   s build --dockerfile ./code/Dockerfile

5. Sebarkan ke Function Compute.

   Jika Anda menjalankan s deploy lagi dengan nama layanan dan fungsi yang sama, jalankan use local terlebih dahulu untuk menggunakan konfigurasi lokal.

   s deploy

6. Buat instans yang disediakan agar fungsi GPU siap menangani permintaan tanpa latensi cold start.

   s provision put --target 1 --qualifier LATEST

7. Verifikasi bahwa instans yang disediakan sudah siap.

   s provision get --qualifier LATEST

   Instans siap digunakan ketika current sama dengan 1. Contoh output:

   [2021-12-14 08:45:24] [INFO] [S-CLI] - Start ...
   [2021-12-14 08:45:24] [INFO] [FC] - Getting provision: tgpu_ffmpeg_service.LATEST/tgpu_ffmpeg_func
   customContainer-demo:
    serviceName:      tgpu_ffmpeg_service
    functionName:      tgpu_ffmpeg_func
    qualifier:       LATEST
    resource:        188077086902****#tgpu_ffmpeg_service#LATEST#tgpu_ffmpeg_func
    target:         1
    current:        1
    scheduledActions:    (empty array)
    targetTrackingPolicies: (empty array)
    currentError:

8. Panggil fungsi tersebut. Periksa versi yang telah disebarkan:

   s invoke

   Transkode dengan CPU:

   s invoke -e '{"method":"GET","headers":{"TRANS-MODE":"cpu"}}'

   Transkode dengan GPU:

   s invoke -e '{"method":"GET","headers":{"TRANS-MODE":"gpu"}}'

9. Setelah selesai, lepas instans yang disediakan untuk menghentikan biaya.

   s provision put --target 0 --qualifier LATEST