Function Compute：Praktik terbaik untuk pemrosesan gambar

Skenario dan manfaat

Berikut adalah manfaat instans yang dipercepat GPU dibandingkan dengan instans tanpa akselerasi GPU di Function Compute:

• Skema aplikasi waktu nyata dan hampir waktu nyata

  • Instans yang dipercepat GPU dapat memproses grafis dan gambar beberapa kali lebih cepat serta menyampaikan konten produksi kepada pengguna secara lebih efisien.

• Skema pemrosesan gambar berprioritas biaya

  • Cadangkan instans yang dipercepat GPU sesuai kebutuhan bisnis Anda. Dengan cara ini, instans yang dipercepat GPU dari Function Compute menawarkan efisiensi biaya yang jauh lebih tinggi daripada kluster GPU yang dibangun sendiri.

  • Gunakan sumber daya GPU dalam mode 1/2 atau eksklusif melalui teknologi virtualisasi GPU. Dengan cara ini, instans yang dipercepat GPU dapat dikonfigurasi secara lebih rinci.

• Skema pemrosesan gambar berprioritas efisiensi

  • Fokus pada pengembangan kode dan tujuan bisnis tanpa perlu melakukan operasi dan pemeliharaan (O&M) pada kluster GPU, seperti manajemen versi driver dan CUDA, manajemen operasi mesin, dan manajemen GPU yang rusak.

Untuk informasi lebih lanjut tentang instans yang dipercepat GPU, lihat Jenis Instans dan Mode Instans.

Deskripsi tutorial

Tabel berikut menunjukkan contoh deteksi tepi pada gambar sumber (kiri) untuk menghasilkan gambar baru (kanan) di Function Compute.

Persiapan

• Kompilasi OpenCV.

  OpenCV harus dikompilasi sebelum Anda dapat menggunakan akselerasi GPU. Berikut adalah cara mengompilasi OpenCV:

  • (Direkomendasikan) Gunakan OpenCV yang sudah dikompilasi menggunakan Docker. Alamat unduhan: opencv-cuda-docker atau cuda-opencv.

  • Kompilasi manual OpenCV. Untuk informasi lebih lanjut, lihat panduan kompilasi.

• Unggah sumber daya audio dan video yang ingin diproses ke Bucket Object Storage Service (OSS) di wilayah tempat instans yang dipercepat GPU berada. Pastikan Anda memiliki izin baca dan tulis pada objek di bucket tersebut. Untuk informasi lebih lanjut tentang cara mengunggah sumber daya audio dan video, lihat Unggah Objek. Untuk informasi lebih lanjut tentang izin, lihat Ubah ACL Bucket.

Menyebarkan aplikasi GPU menggunakan Serverless Devs

Before you start

• Lakukan operasi berikut di wilayah tempat instans yang dipercepat GPU berada:

  • Buat instance Container Registry Enterprise Edition atau Personal Edition. Kami merekomendasikan Anda membuat instance Enterprise Edition. Untuk informasi lebih lanjut, lihat Langkah 1: Buat Instance Container Registry Enterprise Edition.

  • Buat namespace dan repositori gambar. Untuk informasi lebih lanjut, lihat Langkah 2: Buat Namespace dan Langkah 3: Buat Repositori Gambar.

• Instal Serverless Devs dan Docker

• Konfigurasikan Serverless Devs

Procedure

1. Buat proyek.

   s init devsapp/start-fc-custom-container-event-python3.9 -d fc-gpu-prj

   Berikut adalah contoh kode yang menunjukkan direktori proyek yang dibuat:

   fc-gpu-prj
   ├── code
   │   ├── app.py        # Kode fungsi.
   │   └── Dockerfile    # Dockerfile: Image Dockerfile yang berisi kode.
   ├── README.md
   └── s.yaml            # Konfigurasi proyek, yang menentukan bagaimana image diterapkan di Function Compute

2. Masuk ke direktori proyek.

   cd fc-gpu-prj

3. Ubah konfigurasi file direktori berdasarkan kebutuhan bisnis Anda.

   • Edit file s.yaml.

     Untuk informasi lebih lanjut tentang parameter dalam file YAML, lihat Spesifikasi YAML.

     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_opencv_service
             internetAccess: true
           function:
             name: tgpu_opencv_func
             description: test gpu for opencv
             handler: not-used
             timeout: 600
             caPort: 9000
             instanceType: fc.gpu.tesla.1
             gpuMemorySize: 8192
             cpu: 4
             memorySize: 16384
             diskSize: 512
             runtime: custom-container
             customContainerConfig:
               #1. Pastikan bahwa namespace:demo dan repositori:gpu-opencv-canny_s telah dibuat sebelumnya di Alibaba Cloud Container Registry.
               #2. Ubah tag dari v0.1 menjadi v0.2 saat Anda memperbarui fungsi nanti dan jalankan s build && s deploy lagi.
               image: registry.cn-shenzhen.aliyuncs.com/demo/gpu-opencv-canny_s:v0.1
             codeUri: ./code
           triggers:
             - name: httpTrigger
               type: http
               config:
                 authType: anonymous
                 methods:
                   - GET
                                     

   • Edit file app.py.

     Contoh:

     # -*- coding: utf-8 -*-
     # python2 dan python3
     
     from __future__ import print_function
     from http.server import HTTPServer, BaseHTTPRequestHandler
     import json
     import sys
     import logging
     import os
     import numpy as np
     import cv2
     import urllib.request
     
     class MyRequest(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 core(self):
             msg = ""
             mode = ""
             if not cv2.cuda.getCudaEnabledDeviceCount():
                 msg = "No CUDA-capable device is detected |"
                 mode = "Mat"
             else:
                 msg = "CUDA-capable device supported |"
                 mode = "UMat"
     
             # Gunakan jalur objek OSS di akun Alibaba Cloud Anda. Anda harus memiliki izin baca dan tulis pada objek tersebut.
             # Unduh gambar sumber dari bucket OSS Anda.
             path = "/tmp/target.jpg"
             self.download("https://your_public_oss/f.png", path)
     
             img = cv2.imread(path)
     
             if mode=='UMat':
                 img = cv2.UMat(img)
             img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
             img = cv2.GaussianBlur(img, (7, 7), 1.5)
             img = cv2.Canny(img, 0, 50)
             if type(img) == 'cv2.UMat':
                 img = cv2.UMat.get(img)
             cv2.imwrite(path, img)
             # Gunakan jalur objek OSS di akun Alibaba Cloud Anda. Anda harus memiliki izin baca dan tulis pada objek tersebut.
             # Unggah gambar baru setelah deteksi tepi ke bucket OSS. Perhatikan bahwa nama gambar baru tidak boleh sama dengan nama gambar sumber.
             self.upload("https://your_public_oss/target.jpg", path)
     
             msg = msg + " process image ok!"
             data = {'result': msg}
             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":"opencv_edge_canny"}
             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('RUN-MODE')
     
             if mode == "ping":
                 self.pong()
             elif mode == "normal":
                 self.core()
             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, MyRequest)
         print("Starting server, listen at: %s:%s" % host)
         server.serve_forever()

   • Edit file Dockerfile.

     Contoh:

     FROM registry.cn-shanghai.aliyuncs.com/serverless_devs/opencv-cuda:cuda-10.2-opencv-4.2
     WORKDIR /usr/src/app
     RUN apt-get install -y build-essential
     RUN apt-get install -y python3
     COPY . .
     CMD [ "python3", "-u", "/usr/src/app/app.py" ]
     EXPOSE 9000

4. Bangun sebuah image.

   s build --dockerfile ./code/Dockerfile

5. Terapkan kode ke Function Compute.

   s deploy

   Catatan

   Jika Anda menjalankan perintah di atas berulang kali dan nama layanan serta nama fungsi tetap tidak berubah, jalankan perintah use local untuk menggunakan konfigurasi lokal.

6. Konfigurasikan instans yang disediakan.

   s provision put --target 1 --qualifier LATEST

7. Periksa apakah instans yang disediakan siap.

   s provision get --qualifier LATEST

   Jika nilai current adalah 1, mode yang disediakan dari instans yang dipercepat GPU siap. Contoh:

   [2021-11-01T13:43:28.308] [INFO ] [S-CLI] - Start ...
   [2021-11-01T13:43:28.521] [INFO ] [FC] - Getting provision: tgpu_opencv_service.LATEST/tgpu_opencv_func
   customContainer-demo:
    serviceName: tgpu_opencv_service
    functionName: tgpu_opencv_func
    qualifier: LATEST
    resource: 188077086902****#tgpu_opencv_service#LATEST#tgpu_opencv_func
    target: 1
    current: 1
    scheduledActions: []
    targetTrackingPolicies: []

8. Panggil fungsi.

   • Lihat versi online

     FC Invoke Result:
     {"function": "opencv_edge_canny"}

   • Lakukan deteksi tepi pada gambar

     s invoke -e '{"method":"GET","headers":{"RUN-MODE":"normal"}}'
     
     enter download: https://your_public_oss/c1.png
     enter upload: https://your_public_oss/target.jpg # Lihat file untuk memeriksa hasil deteksi tepi.
     FC Invoke Result:
     {"result": "CUDA-capable device supported | process image ok!"}

9. Lepas instans yang dipercepat GPU.

   s provision put --target 0 --qualifier LATEST

Gunakan konsol Function Compute untuk menyebarkan aplikasi GPU

1. Terapkan sebuah image.

   1. Buat instance Container Registry Enterprise Edition atau Container Registry Personal Edition.

      Kami merekomendasikan Anda membuat instance Enterprise Edition. Untuk informasi lebih lanjut, lihat Buat Instance Container Registry Enterprise Edition.

   2. Buat namespace dan repositori gambar.

      Untuk informasi lebih lanjut, lihat bagian Langkah 2: Buat Namespace dan Langkah 3: Buat Repositori Gambar dari topik "Gunakan Instance Container Registry Enterprise Edition untuk Membangun Image".

   3. Lakukan operasi pada Docker sesuai petunjuk di konsol Container Registry. Kemudian, dorong contoh sampel app.py dan Dockerfile ke repositori image instance. Untuk informasi lebih lanjut tentang file-file tersebut, lihat app.py dan Dockerfile di direktori /code saat Anda menyebarkan aplikasi GPU menggunakan Serverless Devs.

      

2. Buat layanan. Untuk informasi lebih lanjut, lihat bagian "Buat Layanan" dari Kelola Layanan.

3. Buat fungsi. Untuk informasi lebih lanjut, lihat Buat Fungsi Wadah Kustom.

   Catatan

   Pilih GPU Instance untuk Instance Type dan Process HTTP Requests untuk Request Handler Type.

4. Ubah periode batas waktu eksekusi fungsi.

   1. Temukan fungsi yang ingin Anda kelola dan klik Configure di kolom Actions.

   2. Di bagian Environment Variables, ubah nilai Execution Timeout Period dan klik Save.

      

   Catatan

   Durasi transkoding menggunakan CPU melebihi nilai default 60 detik. Oleh karena itu, kami merekomendasikan Anda menetapkan nilai Execution Timeout Period ke nilai yang lebih besar.

5. Konfigurasikan instans GPU yang disediakan.

   1. Di halaman detail fungsi, klik tab Auto Scaling dan klik Create Rule.

   2. Di halaman yang muncul, konfigurasikan parameter berikut untuk menyediakan instans GPU dan klik Create.

      Untuk informasi lebih lanjut tentang cara mengonfigurasi instans yang disediakan, lihat Konfigurasikan Instansyang Disediakan dan Aturan Penskalaan Otomatis.

   Setelah konfigurasi selesai, Anda dapat memeriksa apakah instans GPU yang disediakan siap dalam daftar aturan. Secara spesifik, periksa apakah nilai Current Reserved Instances adalah jumlah instans yang disediakan yang ditentukan.

6. Gunakan cURL untuk menguji fungsi.

   1. Di halaman detail fungsi, klik tab Triggers untuk melihat konfigurasi pemicu dan mendapatkan titik akhir pemicu.

   2. Jalankan perintah berikut di CLI untuk memanggil fungsi yang dipercepat GPU:

      • Lihat versi fungsi online

        curl "https://tgpu-op-console-tgpu-op-console-ajezokddpx.cn-shenzhen.fcapp.run"
        {"function": "opencv_edge_canny"}

      • Lakukan deteksi tepi pada gambar

        curl "https://tgpu-op-console-tgpu-op-console-ajezokddpx.cn-shenzhen.fcapp.run" -H "RUN-MODE: normal"
        {"result": "CUDA-capable device supported | process image ok!"}