1. Wprowadzenie
Przegląd
W tym ćwiczeniu utworzysz usługę Cloud Run napisaną w Node.js, która zawiera wizualny opis każdej sceny w filmie. Najpierw usługa użyje interfejsu Video Intelligence API, aby wykryć sygnatury czasowe, w których zmienia się scena. Następnie usługa użyje pliku binarnego innej firmy o nazwie ffmpeg, aby zrobić zrzut ekranu dla każdej sygnatury czasowej zmiany sceny. Na koniec funkcja generowania opisów treści wizualnych w Vertex AI służy do tworzenia opisów wizualnych zrzutów ekranu.
W tym ćwiczeniu w Codelabs pokazujemy też, jak używać ffmpeg w usłudze Cloud Run do przechwytywania obrazów z filmu w danym momencie. Ponieważ ffmpeg musi być zainstalowany oddzielnie, w tym ćwiczeniu pokazujemy, jak utworzyć plik Dockerfile, aby zainstalować ffmpeg jako część usługi Cloud Run.
Usługa Cloud Run działa w ten sposób:
Czego się nauczysz
- Jak utworzyć obraz kontenera za pomocą pliku Dockerfile, aby zainstalować binarny plik innej firmy
- Jak przestrzegać zasady jak najmniejszych uprawnień, tworząc konto usługi dla usługi Cloud Run, aby wywoływać inne usługi Google Cloud
- Jak używać biblioteki klienta Video Intelligence w usłudze Cloud Run
- Jak wywołać interfejsy API Google, aby uzyskać opis wizualny każdej sceny z Vertex AI
2. Konfiguracja i wymagania
Wymagania wstępne
- Jesteś zalogowany(-a) w konsoli Google Cloud.
- Usługa Cloud Run została już wdrożona. Na początek możesz na przykład skorzystać z krótkiego wprowadzenia dotyczącego wdrażania usługi sieciowej z kodu źródłowego.
Aktywowanie Cloud Shell
- W konsoli Cloud kliknij Aktywuj Cloud Shell
.
Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni z opisem tego środowiska. Jeśli pojawił się ekran pośredni, kliknij Dalej.
Uzyskanie dostępu do środowiska Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Większość zadań w tym ćwiczeniu, a być może wszystkie, możesz wykonać w przeglądarce.
Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu.
- Aby potwierdzić, że uwierzytelnianie zostało przeprowadzone, uruchom w Cloud Shell to polecenie:
gcloud auth list
Wynik polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:
gcloud config list project
Wynik polecenia
[core] project = <PROJECT_ID>
Jeśli nie, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Wynik polecenia
Updated property [core/project].
3. Włączanie interfejsów API i ustawianie zmiennych środowiskowych
Zanim zaczniesz korzystać z tego ćwiczenia w Codelabs, musisz włączyć kilka interfejsów API. W tym ćwiczeniu musisz użyć tych interfejsów API: Możesz włączyć te interfejsy API, uruchamiając to polecenie:
gcloud services enable run.googleapis.com \
storage.googleapis.com \
cloudbuild.googleapis.com \
videointelligence.googleapis.com \
aiplatform.googleapis.com
Następnie możesz ustawić zmienne środowiskowe, których będziesz używać podczas naszych ćwiczeń z programowania.
REGION=<YOUR-REGION> PROJECT_ID=<YOUR-PROJECT-ID> PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)') SERVICE_NAME=video-describer export BUCKET_ID=$PROJECT_ID-video-describer
4. Tworzenie zasobnika Cloud Storage
Utwórz zasobnik Cloud Storage, do którego możesz przesyłać filmy do przetworzenia przez usługę Cloud Run, za pomocą tego polecenia:
gsutil mb -l us-central1 gs://$BUCKET_ID/
[Opcjonalnie] Możesz użyć tego przykładowego filmu, pobierając go lokalnie.
gsutil cp gs://cloud-samples-data/video/visionapi.mp4 testvideo.mp4
Teraz prześlij plik wideo do zasobnika na dane.
FILENAME=<YOUR-VIDEO-FILENAME> gsutil cp $FILENAME gs://$BUCKET_ID
5. Tworzenie aplikacji Node.js
Najpierw utwórz katalog kodu źródłowego i przejdź do niego.
mkdir video-describer && cd $_
Następnie utwórz plik package.json o tej treści:
{
"name": "video-describer",
"version": "1.0.0",
"private": true,
"description": "describes the image in every scene for a given video",
"main": "index.js",
"author": "Google LLC",
"license": "Apache-2.0",
"scripts": {
"start": "node index.js"
},
"dependencies": {
"@google-cloud/storage": "^7.7.0",
"@google-cloud/video-intelligence": "^5.0.1",
"axios": "^1.6.2",
"express": "^4.18.2",
"fluent-ffmpeg": "^2.1.2",
"google-auth-library": "^9.4.1"
}
}
Ta aplikacja składa się z kilku plików źródłowych, co poprawia czytelność. Najpierw utwórz plik źródłowy index.js z tą treścią: Ten plik zawiera punkt wejścia usługi i główną logikę aplikacji.
const { captureImages } = require('./imageCapture.js');
const { detectSceneChanges } = require('./sceneDetector.js');
const transcribeScene = require('./imageDescriber.js');
const { Storage } = require('@google-cloud/storage');
const fs = require('fs').promises;
const path = require('path');
const express = require('express');
const app = express();
const bucketName = process.env.BUCKET_ID;
const port = parseInt(process.env.PORT) || 8080;
app.listen(port, () => {
console.log(`video describer service ready: listening on port ${port}`);
});
// entry point for the service
app.get('/', async (req, res) => {
try {
// download the requested video from Cloud Storage
let videoFilename = req.query.filename;
console.log("processing file: " + videoFilename);
// download the file to locally to the Cloud Run instance
let localFilename = await downloadVideoFile(videoFilename);
// detect all the scenes in the video & save timestamps to an array
let timestamps = await detectSceneChanges(localFilename);
console.log("Detected scene changes at the following timestamps: ", timestamps);
// create an image of each scene change
// and save to a local directory called "output"
await captureImages(localFilename, timestamps);
// get an access token for the Service Account to call the Google APIs
let accessToken = await transcribeScene.getAccessToken();
console.log("got an access token");
let imageBaseName = path.parse(localFilename).name;
// the data structure for storing the scene description and timestamp
// e.g. an array of json objects {timestamp: 1, description: "..."}, etc.
let scenes = []
// for each timestamp, send the image to Vertex AI
console.log("getting Vertex AI description all the timestamps");
scenes = await Promise.all(
timestamps.map(async (timestamp) => {
let filepath = path.join("./output", imageBaseName + "-" + timestamp + ".png");
// get the base64 encoded image
const encodedFile = await fs.readFile(filepath, 'base64');
// send each screenshot to Vertex AI for description
let description = await transcribeScene.transcribeScene(accessToken, encodedFile)
return { timestamp: timestamp, description: description };
}));
console.log("finished collecting all the scenes");
//console.log(scenes);
return res.json(scenes);
} catch (error) {
//return an error
console.log("received error: ", error);
return res.status(500).json("an internal error occurred");
}
});
async function downloadVideoFile(videoFilename) {
// Creates a client
const storage = new Storage();
// keep same name locally
let localFilename = videoFilename;
const options = {
destination: localFilename
};
// Download the file
await storage.bucket(bucketName).file(videoFilename).download(options);
console.log(
`gs://${bucketName}/${videoFilename} downloaded locally to ${localFilename}.`
);
return localFilename;
}
Następnie utwórz plik sceneDetector.js o tej treści: Ten plik używa interfejsu Video Intelligence API do wykrywania zmian scen w filmie.
const fs = require('fs');
const util = require('util');
const readFile = util.promisify(fs.readFile);
const ffmpeg = require('fluent-ffmpeg');
const Video = require('@google-cloud/video-intelligence');
const client = new Video.VideoIntelligenceServiceClient();
module.exports = {
detectSceneChanges: async function (downloadedFile) {
// Reads a local video file and converts it to base64
const file = await readFile(downloadedFile);
const inputContent = file.toString('base64');
// setup request for shot change detection
const videoContext = {
speechTranscriptionConfig: {
languageCode: 'en-US',
enableAutomaticPunctuation: true,
},
};
const request = {
inputContent: inputContent,
features: ['SHOT_CHANGE_DETECTION'],
};
// Detects camera shot changes
const [operation] = await client.annotateVideo(request);
console.log('Shot (scene) detection in progress...');
const [operationResult] = await operation.promise();
// Gets shot changes
const shotChanges = operationResult.annotationResults[0].shotAnnotations;
console.log("Shot (scene) changes detected: " + shotChanges.length);
// data structure to be returned
let sceneChanges = [];
// for the initial scene
sceneChanges.push(1);
// if only one scene, keep at 1 second
if (shotChanges.length === 1) {
return sceneChanges;
}
// get length of video
const videoLength = await getVideoLength(downloadedFile);
shotChanges.forEach((shot, shotIndex) => {
if (shot.endTimeOffset === undefined) {
shot.endTimeOffset = {};
}
if (shot.endTimeOffset.seconds === undefined) {
shot.endTimeOffset.seconds = 0;
}
if (shot.endTimeOffset.nanos === undefined) {
shot.endTimeOffset.nanos = 0;
}
// convert to a number
let currentTimestampSecond = Number(shot.endTimeOffset.seconds);
let sceneChangeTime = 0;
// double-check no scenes were detected within the last second
if (currentTimestampSecond + 1 > videoLength) {
sceneChangeTime = currentTimestampSecond;
} else {
// otherwise, for simplicity, just round up to the next second
sceneChangeTime = currentTimestampSecond + 1;
}
sceneChanges.push(sceneChangeTime);
});
return sceneChanges;
}
}
async function getVideoLength(localFile) {
let getLength = util.promisify(ffmpeg.ffprobe);
let length = await getLength(localFile);
console.log("video length: ", length.format.duration);
return length.format.duration;
}
Teraz utwórz plik o nazwie imageCapture.js z tą zawartością. Ten plik używa pakietu węzła fluent-ffmpeg do uruchamiania poleceń ffmpeg w aplikacji węzła.
const ffmpeg = require('fluent-ffmpeg');
const path = require('path');
const util = require('util');
module.exports = {
captureImages: async function (localFile, scenes) {
let imageBaseName = path.parse(localFile).name;
try {
for (scene of scenes) {
console.log("creating screenshot for scene: ", + scene);
await createScreenshot(localFile, imageBaseName, scene);
}
} catch (error) {
console.log("error gathering screenshots: ", error);
}
console.log("finished gathering the screenshots");
}
}
async function createScreenshot(localFile, imageBaseName, scene) {
return new Promise((resolve, reject) => {
ffmpeg(localFile)
.screenshots({
timestamps: [scene],
filename: `${imageBaseName}-${scene}.png`,
folder: 'output',
size: '320x240'
}).on("error", () => {
console.log("Failed to create scene for timestamp: " + scene);
return reject('Failed to create scene for timestamp: ' + scene);
})
.on("end", () => {
return resolve();
});
})
}
Na koniec utwórz plik o nazwie „imageDescriber.js” z tą treścią. Ten plik korzysta z Vertex AI, aby uzyskać opis wizualny każdego obrazu sceny.
const axios = require("axios");
const { GoogleAuth } = require('google-auth-library');
const auth = new GoogleAuth({
scopes: 'https://www.googleapis.com/auth/cloud-platform'
});
module.exports = {
getAccessToken: async function () {
return await auth.getAccessToken();
},
transcribeScene: async function(token, encodedFile) {
let projectId = await auth.getProjectId();
let config = {
headers: {
'Authorization': 'Bearer ' + token,
'Content-Type': 'application/json; charset=utf-8'
}
}
const json = {
"instances": [
{
"image": {
"bytesBase64Encoded": encodedFile
}
}
],
"parameters": {
"sampleCount": 1,
"language": "en"
}
}
let response = await axios.post('https://us-central1-aiplatform.googleapis.com/v1/projects/' + projectId + '/locations/us-central1/publishers/google/models/imagetext:predict', json, config);
return response.data.predictions[0];
}
}
Tworzenie pliku Dockerfile i pliku .dockerignore
Ponieważ ta usługa korzysta z ffmpeg, musisz utworzyć plik Dockerfile, który zainstaluje ffmpeg.
Utwórz plik o nazwie Dockerfile z tą zawartością:
# Copyright 2020 Google, LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Use the official lightweight Node.js image. # https://hub.docker.com/_/node FROM node:20.10.0-slim # Create and change to the app directory. WORKDIR /usr/src/app RUN apt-get update && apt-get install -y ffmpeg # Copy application dependency manifests to the container image. # A wildcard is used to ensure both package.json AND package-lock.json are copied. # Copying this separately prevents re-running npm install on every code change. COPY package*.json ./ # Install dependencies. # If you add a package-lock.json speed your build by switching to 'npm ci'. # RUN npm ci --only=production RUN npm install --production # Copy local code to the container image. COPY . . # Run the web service on container startup. CMD [ "npm", "start" ]
Utwórz też plik o nazwie .dockerignore, aby zignorować konteneryzację niektórych plików.
Dockerfile .dockerignore node_modules npm-debug.log
6. Tworzenie konta usługi
Utworzysz konto usługi, które będzie używane przez usługę Cloud Run do uzyskiwania dostępu do Cloud Storage, Vertex AI i interfejsu Video Intelligence API.
SERVICE_ACCOUNT="cloud-run-video-description" SERVICE_ACCOUNT_ADDRESS=$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com gcloud iam service-accounts create $SERVICE_ACCOUNT \ --display-name="Cloud Run Video Scene Image Describer service account" # to view & download storage bucket objects gcloud projects add-iam-policy-binding $PROJECT_ID \ --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \ --role=roles/storage.objectViewer # to call the Vertex AI imagetext model gcloud projects add-iam-policy-binding $PROJECT_ID \ --member serviceAccount:$SERVICE_ACCOUNT_ADDRESS \ --role=roles/aiplatform.user
7. Wdrażanie usługi Cloud Run
Teraz możesz użyć wdrożenia opartego na źródle, aby automatycznie kontenerować usługę Cloud Run.
Uwaga: domyślny czas przetwarzania usługi Cloud Run to 60 sekund. W tym ćwiczeniu używamy 5-minutowego limitu czasu, ponieważ sugerowany film testowy trwa 2 minuty. Jeśli używasz dłuższego filmu, może być konieczne zmodyfikowanie czasu.
gcloud run deploy $SERVICE_NAME \ --region=$REGION \ --set-env-vars BUCKET_ID=$BUCKET_ID \ --no-allow-unauthenticated \ --service-account $SERVICE_ACCOUNT_ADDRESS \ --timeout=5m \ --source=.
Po wdrożeniu zapisz adres URL usługi w zmiennej środowiskowej.
SERVICE_URL=$(gcloud run services describe $SERVICE_NAME --platform managed --region $REGION --format 'value(status.url)')
8. Wywoływanie usługi Cloud Run
Teraz możesz wywołać usługę, podając nazwę filmu przesłanego do Cloud Storage.
curl -X GET -H "Authorization: Bearer $(gcloud auth print-identity-token)" ${SERVICE_URL}?filename=${FILENAME}
Wyniki powinny wyglądać podobnie do tych poniżej:
[{"timestamp":1,"description":"an aerial view of a city with a bridge in the background"},{"timestamp":7,"description":"a man in a blue shirt sits in front of shelves of donuts"},{"timestamp":11,"description":"a black and white photo of people working in a bakery"},{"timestamp":12,"description":"a black and white photo of a man and woman working in a bakery"}]
9. Gratulacje!
Gratulujemy ukończenia ćwiczenia!
Zalecamy zapoznanie się z dokumentacją Video Intelligence API, Cloud Run i Vertex AI do generowania opisów treści wizualnych.
Omówione zagadnienia
- Jak utworzyć obraz kontenera za pomocą pliku Dockerfile, aby zainstalować binarny plik innej firmy
- Jak przestrzegać zasady jak najmniejszych uprawnień, tworząc konto usługi dla usługi Cloud Run, aby wywoływać inne usługi Google Cloud
- Jak używać biblioteki klienta Video Intelligence w usłudze Cloud Run
- Jak wywołać interfejsy API Google, aby uzyskać opis wizualny każdej sceny z Vertex AI
10. Czyszczenie danych
Aby uniknąć przypadkowych opłat (np. jeśli ta usługa Cloud Run zostanie przypadkowo wywołana więcej razy niż miesięczny limit wywołań Cloud Run w ramach bezpłatnej wersji), możesz usunąć usługę Cloud Run lub projekt utworzony w kroku 2.
Aby usunąć usługę Cloud Run, otwórz konsolę Cloud Run w Cloud Console na stronie https://console.cloud.google.com/run/ i usuń funkcję video-describer (lub $SERVICE_NAME, jeśli używasz innej nazwy).
Jeśli zdecydujesz się usunąć cały projekt, otwórz stronę https://console.cloud.google.com/cloud-resource-manager, wybierz projekt utworzony w kroku 2 i kliknij Usuń. Jeśli usuniesz projekt, musisz zmienić projekty w Cloud SDK. Listę wszystkich dostępnych projektów możesz wyświetlić, uruchamiając polecenie gcloud projects list.