So verwenden Sie die YouTube-API zum Hochladen von Videos auf dem YouTube-Kanal
Jeder kennt YouTube. YouTube ist die Nummer eins unter den Video-Sharing-Plattformen der Welt. Wir können YouTube verwenden, um unsere Videos zu hosten. Dadurch sparen wir viel Serverplatz und man kann das YouTube-Video problemlos auf der Website einbetten. Jeder kann das Video auf YouTube hochladen. Melden Sie sich einfach bei Ihrem YouTube-Konto an und laden Sie das Video hoch. Einfacher und unkomplizierter Prozess. Aber was ist, wenn jemand Videos über die YouTube-API auf einen YouTube-Kanal hochladen muss? Ist es möglich? Ja, es ist möglich. In diesem Artikel untersuchen wir, wie Sie die YouTube-API verwenden, um ein Video mit PHP hochzuladen.
Registrieren Sie eine Anwendung und erstellen Sie Anmeldeinformationen
Um mit der YouTube API zu beginnen, benötigen Sie ein Google-Konto. Sobald Sie ein Google-Konto haben, registrieren Sie Ihre Anwendung und erhalten Sie die API-Schlüssel.
Nachfolgend finden Sie die Schritte zum Registrieren einer Anwendung und zum Abrufen Ihrer API-Schlüssel.
- Gehen Sie zur Google-Entwicklerkonsole https://console.developers.google.com
- Erstellen Sie ein neues Projekt. Sie können auch ein vorhandenes Projekt auswählen.
- Geben Sie einen Namen für Ihr Projekt ein. Die Google Console erstellt eine eindeutige Projekt-ID.
- Nachdem Sie ein Projekt erstellt haben, wird es oben in der linken Seitenleiste angezeigt.
- Klicken Sie auf Bibliothek. Sie sehen eine Liste der Google APIs.
- Aktivieren Sie die YouTube-Daten-API.
- Klicken Sie auf die Anmeldeinformationen. Wählen Sie unter Anmeldeinformationen erstellen die OAuth-Client-ID aus. Wählen Sie das Optionsfeld für Webanwendung aus.
- Geben Sie den Namen an. Geben Sie unter Autorisierte JavaScript-Ursprünge Ihre Domain-URL ein. Geben Sie in den Autorisierte Weiterleitungs-URIs den Link der Weiterleitungs-URL an. In meinem Fall habe ich die URL http://localhost/youtube/callback.php übergeben.
- Klicken Sie auf die Schaltfläche Erstellen. Sie erhalten die Client-ID und das Client-Geheimnis im Popup. Kopieren Sie diese Angaben. Wir werden es gleich brauchen.
Richten Sie eine Basiskonfiguration ein
Zum Hochladen von Videos über die YouTube-API müssen Sie ein Zugriffstoken erstellen. Ein Zugriffstoken ist nichts anderes als eine Kennung eines YouTube-Kontos.
Das Zugriffstoken läuft jedoch nach einiger Zeit ab. Sobald das Zugriffstoken abgelaufen ist, erhalten Sie die Fehlermeldung "Unberechtigter Zugriff". Die Lösung hierfür besteht darin, den Autorisierungsprozess erneut auszuführen oder den Zugriffstoken im Hintergrund neu zu generieren und den Upload-Vorgang abzuschließen. In diesem Artikel gehe ich für eine zweite Lösung. Wir werden das Zugriffstoken neu generieren, wenn es im Hintergrund abgelaufen ist, ohne den Upload-Prozess zu unterbrechen. Auf diese Weise müssen Sie den Autorisierungsvorgang nicht immer wieder durchführen.
Allerdings müssen Sie zuerst das Konto autorisieren, um ein Zugriffstoken zu generieren. Ich werde die Hybridauth- Bibliothek zur Autorisierung und zum Generieren von Zugriffstoken verwenden. Öffnen Sie Ihre composer.jsonDatei und fügen Sie die folgenden Zeilen hinzu.
{
"require": {
"google/apiclient": "2.0",
"hybridauth/hybridauth": "~3.0"
}
}Beachten Sie YouTube ist das Produkt von Google und YouTube API ist nichts anderes als eine Google API. Aus diesem Grund verwenden wir die Bibliothek "google/apiclient". Führen Sie als nächstes den folgenden Befehl aus, um diese Bibliotheken zu installieren.
composer installDatenbankkonfiguration
Bei jedem API-Aufruf müssen wir ein Zugriffstoken senden, also speichern Sie es in der Datenbank. Erstellen Sie mit der folgenden Abfrage ein Tabellen-‘Token’ in Ihrer Datenbank.
CREATE TABLE `token` ( `id` int(11) NOT NULL AUTO_INCREMENT,
`access_token` text NOT NULL,
PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4Später in diesem Artikel müssen wir mit dieser ‘Token’-Tabelle interagieren, um Token-Details abzurufen und zu aktualisieren. Das erfordert das Schreiben einer Datenbankverbindung und einige Abfragen. Erstellen Sie eine Datei class-db.phpund fügen Sie den folgenden Code hinzu.
class-db.php
<?php
class DB {
private $dbHost = "DB_HOST";
private $dbUsername = "DB_USERNAME";
private $dbPassword = "DB_PASSWORD";
private $dbName = "DB_NAME";
public function __construct(){
if(!isset($this->db)){
// Connect to the database
$conn = new mysqli($this->dbHost, $this->dbUsername, $this->dbPassword, $this->dbName);
if($conn->connect_error){
die("Failed to connect with MySQL: ". $conn->connect_error);
}else{
$this->db = $conn;
}
}
}
public function is_table_empty() {
$result = $this->db->query("SELECT id FROM token");
if($result->num_rows) {
return false;
}
return true;
}
public function get_access_token() {
$sql = $this->db->query("SELECT access_token FROM token");
$result = $sql->fetch_assoc();
return json_decode($result['access_token']);
}
public function get_refersh_token() {
$result = $this->get_access_token();
return $result->refresh_token;
}
public function update_access_token($token) {
if($this->is_table_empty()) {
$this->db->query("INSERT INTO token(access_token) VALUES('$token')");
} else {
$this->db->query("UPDATE token SET access_token = '$token' WHERE id = (SELECT id FROM token)");
}
}
}Übergeben Sie Ihre Datenbankanmeldeinformationen in der obigen Datei. Hier gehe ich davon aus, dass Sie ein einzelnes YouTube-Konto verwenden möchten. Wenn Sie mehrere Konten verwenden möchten, ändern Sie die obigen Abfragen gemäß Ihren Anforderungen.
Zugriffstoken generieren
Sie haben die Bibliotheken installiert und eine Tabelle zum Speichern des Tokens erstellt. Lassen Sie uns nun den Autorisierungsprozess durchführen, das Zugriffstoken greifen und in der Tabelle ‘token’ speichern.
Erstellen Sie eine config.phpDatei und schreiben Sie eine Konfiguration gemäß den Richtlinien der HybridAuth-Bibliothek.
config.php
<?php
require_once 'vendor/autoload.php';
require_once 'class-db.php';
define('GOOGLE_CLIENT_ID', 'PASTE_CLIENT_ID_HERE');
define('GOOGLE_CLIENT_SECRET', 'PASTE_CLIENT_SECRET_HERE');
$config = [
'callback' => 'YOUR_DOMAIN_URL/callback.php',
'keys' => [
'id' => GOOGLE_CLIENT_ID,
'secret' => GOOGLE_CLIENT_SECRET
],
'scope' => 'https://www.googleapis.com/auth/youtube https://www.googleapis.com/auth/youtube.upload',
'authorize_url_parameters' => [
'approval_prompt' => 'force', // to pass only when you need to acquire a new refresh token.
'access_type' => 'offline'
]
];
$adapter = new HybridauthProviderGoogle( $config );Ersetzen Sie die Platzhalter durch die tatsächlichen Werte Ihrer Google-Anmeldeinformationen. Fügen Sie dieselbe Rückruf-URL hinzu, die Sie beim Erstellen der Konsolenanwendung übergeben haben. Dies bedeutet, dass der Benutzer nach Abschluss des Autorisierungsvorgangs zur callback.phpDatei umleitet .
In der callback.phpDatei holen wir die Details des Zugriffstokens ab und speichern sie in der Datenbank.
callback.php
<?php
require_once 'config.php';
try {
$adapter->authenticate();
$token = $adapter->getAccessToken();
$db = new DB();
if($db->is_table_empty()) {
$db->update_access_token(json_encode($token));
echo "Access token inserted successfully.";
}
}
catch( Exception $e ){
echo $e->getMessage() ;
}Gehen Sie zu Ihrem Browser und führen Sie YOUR_DOMAIN_URL/callback.php aus. Sie werden zum Google-Konto weitergeleitet, schließen den Autorisierungsprozess ab und Sie sollten die Erfolgsmeldung sehen. Überprüfen Sie die Datenbanktabelle ‘token’. Es sollten Ihre Token-Details gespeichert sein. Und das bedeutet, dass Sie bereit sind, ein Video auf Ihrem YouTube-Kanal hochzuladen.
Hochladen von Videos auf dem YouTube-Kanal mithilfe der YouTube-API
Sie haben das Zugriffstoken erhalten, das zum Hochladen des Videos auf den YouTube-Kanal über die Google-API verwendet wird. Aber wie bereits erwähnt, würde der Zugriffstoken nach einiger Zeit ablaufen und wir werden ihn im Hintergrund neu generieren, ohne erneut nach einem Autorisierungsvorgang zu fragen.
Wir können dies mit ‘refersh_token’ tun. Wenn Sie sich die Spalte ‘access_token’ in der Tabelle ansehen, sehen Sie, dass sie auch den Eintrag von ‘refresh_token’ enthält. Mit dem ‘refresh_token’ rufen wir den ‘/o/oauth2/token’-Endpunkt auf und generieren das Zugriffstoken im Hintergrund neu.
Als nächstes benötigen Sie das HTML-Formular, über das Sie das Video durchsuchen und zum Hochladen an den Server senden können. Lassen Sie uns wie folgt ein einfaches HTML-Formular erstellen.
index.php
<form method="post" enctype="multipart/form-data">
<p><input type="text" name="title" placeholder="Enter Video Title" /></p>
<p><textarea name="summary" cols="30" rows="10" placeholder="Video description"></textarea></p>
<p><input type="file" name="file"/></p>
<input type="submit" name="submit" value="Submit" />
</form>Das Formular hat 3 Felder – Titel, Beschreibung und Datei. Nach dem Absenden dieses Formulars sollte das Video zusammen mit dem bereitgestellten Titel und der Beschreibung auf Ihrem YouTube-Kanal hochgeladen werden.
index.php
<?php
require_once 'config.php';
if (isset($_POST['submit'])) {
$arr_data = array(
'title' => $_POST['title'],
'summary' => $_POST['summary'],
'video_path' => $_FILES['file']['tmp_name'],
);
upload_video_on_youtube($arr_data);
}
function upload_video_on_youtube($arr_data) {
$client = new Google_Client();
$db = new DB();
$arr_token = (array) $db->get_access_token();
$accessToken = array(
'access_token' => $arr_token['access_token'],
'expires_in' => $arr_token['expires_in'],
);
$client->setAccessToken($accessToken);
$service = new Google_Service_YouTube($client);
$video = new Google_Service_YouTube_Video();
$videoSnippet = new Google_Service_YouTube_VideoSnippet();
$videoSnippet->setDescription($arr_data['summary']);
$videoSnippet->setTitle($arr_data['title']);
$video->setSnippet($videoSnippet);
$videoStatus = new Google_Service_YouTube_VideoStatus();
$videoStatus->setPrivacyStatus('public');
$video->setStatus($videoStatus);
try {
$response = $service->videos->insert(
'snippet,status',
$video,
array(
'data' => file_get_contents($arr_data['video_path']),
'mimeType' => 'video/*',
'uploadType' => 'multipart'
)
);
echo "Video uploaded successfully. Video id is ". $response->id;
} catch(Exception $e) {
if( 401 == $e->getCode()) {
$refresh_token = $db->get_refersh_token();
$client = new GuzzleHttpClient(['base_uri' => 'https://accounts.google.com']);
$response = $client->request('POST', '/o/oauth2/token', [
'form_params' => [
"grant_type" => "refresh_token",
"refresh_token" => $refresh_token,
"client_id" => GOOGLE_CLIENT_ID,
"client_secret" => GOOGLE_CLIENT_SECRET,
],
]);
$data = (array) json_decode($response->getBody());
$data['refresh_token'] = $refresh_token;
$db->update_access_token(json_encode($data));
upload_video_on_youtube($arr_data);
} else {
//echo $e->getMessage(); //print the error just in case your video is not uploaded.
}
}
}
?>Der obige Code nimmt eine Videodatei aus dem HTML-Formular und lädt sie über die API in Ihren YouTube-Kanal hoch. Wenn Ihr Zugriffstoken abgelaufen ist, wird der Token im Hintergrund neu generiert und der Vorgang fortgesetzt, ohne ihn zu beschädigen.
Laden Sie ein benutzerdefiniertes Thumbnail auf YouTube-Video hoch
Wenn Sie eine benutzerdefinierte Anwendung erstellen, die YouTube-Videos verwaltet, möchten Sie wahrscheinlich Miniaturansichten auf YouTube-Videos hochladen. Um ein benutzerdefiniertes Thumbnail hochzuladen, müssen Nutzer ihre Telefonnummer mit ihrem YouTube-Konto bestätigen. Besuchen Sie den Linkhttps://www.youtube.com/features und führen Sie die Überprüfung der Telefonnummer durch.
Sobald Sie die Telefonnummer bestätigt haben, können Sie unser vorheriges Formular und unseren Code mit kleinen Änderungen verwenden und das benutzerdefinierte Thumbnail für das hochgeladene Video festlegen. Fügen Sie zunächst das Formularfeld hinzu, das das Hochladen von Bildern ermöglicht. Die empfohlene Größe der YouTube-Miniaturansicht ist 1280x720.
<p>
<label>Image</label>
<input type="file" name="image" accept="image/*" />
</p>Beim Absenden des Formulars haben wir ein Array erstellt, $arr_datadas alle Formulardaten enthält. Fügen Sie das neue Bildpaar $arr_datawie folgt zum Array hinzu .
$arr_data = array(
'title' => $_POST['title'],
'summary' => $_POST['summary'],
'video_path' => $_FILES['file']['tmp_name'],
'image_path' => $_FILES['image']['tmp_name'], // here we are passing image
);Nachdem unser Code das Video auf YouTube hochgeladen hat, müssen wir als Nächstes die Video-ID nehmen und dem Video ein benutzerdefiniertes Thumbnail zuweisen.
<?php
...
...
echo "Video uploaded successfully. Video id is ". $response->id;
//upload thumbnail
$videoId = $response->id;
$chunkSizeBytes = 1 * 1024 * 1024;
$client->setDefer(true);
$setRequest = $service->thumbnails->set($videoId);
$media = new Google_Http_MediaFileUpload(
$client,
$setRequest,
'image/png',
null,
true,
$chunkSizeBytes
);
$imagePath = $arr_data['image_path'];
$media->setFileSize(filesize($imagePath));
$status = false;
$handle = fopen($imagePath, "rb");
while (!$status && !feof($handle)) {
$chunk = fread($handle, $chunkSizeBytes);
$status = $media->nextChunk($chunk);
}
fclose($handle);
$client->setDefer(false);
echo "<br>Thumbanil: ". $status['items'][0]['default']['url'];Löschen Sie Videos aus dem YouTube-Kanal mit der YouTube-API
Möglicherweise möchten Sie auch einen Code zum Löschen von Videos mithilfe der YouTube-API. Um ein Video zu löschen, benötigst du einen zusätzlichen Scope, https://www.googleapis.com/auth/youtubeden ich oben bereits in einer Konfigurationsdatei eingebunden habe. Das bedeutet, dass das durch Befolgen der obigen Schritte generierte Zugriffstoken zum Löschen eines Videos verwendet werden kann.
Unten ist der Code, der ein Video von Ihrem YouTube-Kanal löscht.
<?php
require_once 'config.php';
delete_video('VIDEO_ID_HERE');
function delete_video($id) {
$client = new Google_Client();
$db = new DB();
$arr_token = (array) $db->get_access_token();
$accessToken = array(
'access_token' => $arr_token['access_token'],
'expires_in' => $arr_token['expires_in'],
);
try {
$client->setAccessToken($accessToken);
$service = new Google_Service_YouTube($client);
$service->videos->delete($id);
} catch(Exception $e) {
if( 401 == $e->getCode()) {
$refresh_token = $db->get_refersh_token();
$client = new GuzzleHttpClient(['base_uri' => 'https://accounts.google.com']);
$response = $client->request('POST', '/o/oauth2/token', [
'form_params' => [
"grant_type" => "refresh_token",
"refresh_token" => $refresh_token,
"client_id" => GOOGLE_CLIENT_ID,
"client_secret" => GOOGLE_CLIENT_SECRET,
],
]);
$data = (array) json_decode($response->getBody());
$data['refresh_token'] = $refresh_token;
$db->update_access_token(json_encode($data));
delete_video($id);
} else {
//echo $e->getMessage(); //print the error just in case your video is not uploaded.
}
}
}Das ist es! Ich hoffe, Sie haben erfahren, wie Sie mithilfe der YouTube-API ein Video auf den YouTube-Kanal hochladen. Ich würde gerne Ihre Gedanken oder Vorschläge im Kommentarbereich unten hören.
Zum Thema passende Artikel
- So laden Sie Videos auf YouTube in der Laravel-Anwendung hoch
- So erhalten Sie YouTube-Video-Tags mit der YouTube-API
- YouTube API – So erhalten Sie eine Liste der YouTube-Videos Ihres Kanals
- So erhalten Sie eine YouTube-Videoliste nach Schlüsselwörtern mit der YouTube-Such-API