Siapa sih yang tidak ingin menyiapkan streaming YouTube dengan cara yang simpel, fleksibel, dan tentunya bisa di‑otomatisasi? Di era sekarang, streaming video YouTube pakai Node.js dan GitHub bukan lagi mimpi yang jauh. Dengan kombinasi Node.js yang ringan serta GitHub Actions yang kuat, kamu bisa membangun, menguji, dan meluncurkan siaran langsung hanya dalam beberapa menit. Artikel ini bakal membawa kamu langkah demi langkah, mulai dari persiapan lingkungan, penulisan kode server, sampai menghubungkannya dengan pipeline CI/CD di GitHub.

Kalau kamu masih baru di dunia backend atau belum familiar dengan YouTube API, tenang saja. Kita bakal kupas tuntas semua komponen yang diperlukan, lengkap dengan contoh kode yang mudah dipahami. Dan yang paling penting, semua penjelasan dibawakan dengan bahasa santai, jadi kamu tidak akan merasa terbebani oleh istilah teknis yang terlalu kaku.

Sebelum masuk ke detail teknis, pastikan kamu memiliki akun Google (untuk mengakses YouTube), akun GitHub, serta laptop atau PC yang cukup kuat untuk menjalankan Node.js dan proses transcoding video. Kalau lagi cari perangkat yang cocok untuk streaming, kamu bisa cek 7 Laptop 2026 Terbaik untuk Streaming – Review Lengkap, Harga, dan Tips Memilih yang Pas! sebagai referensi.

Persiapan Lingkungan Pengembangan

Jual Pin Kementerian Lingkungan Hidup dan Kehutanan RI Pin Logo Murah

1. Install Node.js dan npm

Node.js adalah runtime JavaScript yang memungkinkan kita menjalankan kode di server. Unduh versi LTS terbaru dari nodejs.org dan ikuti langkah instalasi sesuai sistem operasi kamu. Setelah selesai, cek instalasi dengan:

node -v
npm -v

Pastikan versi yang muncul adalah yang terbaru, karena beberapa paket streaming memerlukan fitur ES6 terbaru.

2. Buat Repository di GitHub

Masuk ke GitHub, buat repository baru (misalnya youtube-stream-node) dan clone ke lokal:

git clone https://github.com/username/youtube-stream-node.git
cd youtube-stream-node

Repository ini nantinya akan menjadi tempat kamu menyimpan kode server, file konfigurasi, serta workflow GitHub Actions.

3. Dapatkan API Key YouTube

Untuk mengakses live stream, kamu perlu Google Cloud Console. Buat proyek baru, aktifkan YouTube Data API v3, dan buat OAuth 2.0 Client ID atau API key yang akan dipakai pada aplikasi Node.js. Simpan key ini dengan aman, nanti kita masukkan ke GitHub Secrets.

4. Siapkan Project Node.js

Inisialisasi project dengan npm:

npm init -y

Lalu instal paket-paket utama:

  • express – Web framework ringan.
  • googleapis – Library resmi Google untuk mengakses YouTube API.
  • fluent-ffmpeg – Wrapper Node.js untuk FFmpeg, berguna untuk transcoding video.
  • dotenv – Membaca variabel lingkungan dari file .env.
npm install express googleapis fluent-ffmpeg dotenv

Membangun Server Streaming dengan Node.js

18 - Membuat Server NodeJS dengan Menggunakan ExpressJS - YouTube

1. Struktur Direktori

Berikut contoh struktur sederhana:

youtube-stream-node/
│
├─ .env
├─ index.js
├─ package.json
└─ streams/
   └─ sample.mp4   (file video contoh)

2. Membuat File .env

Masukkan credential yang diperlukan:

YOUTUBE_API_KEY=YOUR_API_KEY
YOUTUBE_CLIENT_ID=YOUR_CLIENT_ID
YOUTUBE_CLIENT_SECRET=YOUR_CLIENT_SECRET
PORT=3000

Jangan lupa menambahkan .env ke .gitignore agar tidak ter‑push ke repo.

3. Kode Server (index.js)

Berikut contoh kode yang meng‑expose endpoint untuk memulai live stream:

require('dotenv').config();
const express = require('express');
const { google } = require('googleapis');
const ffmpeg = require('fluent-ffmpeg');
const path = require('path');

const app = express();
const youtube = google.youtube('v3');

const oauth2Client = new google.auth.OAuth2(
  process.env.YOUTUBE_CLIENT_ID,
  process.env.YOUTUBE_CLIENT_SECRET,
  'http://localhost:' + process.env.PORT + '/oauth2callback'
);

// Middleware untuk meng‑parse JSON
app.use(express.json());

// Endpoint untuk mendapatkan URL ingest (RTMP) dan ID broadcast
app.post('/create-broadcast', async (req, res) => {
  const { title, description } = req.body;
  try {
    // 1️⃣ Buat broadcast
    const broadcastRes = await youtube.liveBroadcasts.insert({
      auth: oauth2Client,
      part: 'snippet,contentDetails,status',
      requestBody: {
        snippet: { title, description },
        contentDetails: { enableClosedCaptions: true },
        status: { privacyStatus: 'unlisted' }
      }
    });

    const broadcastId = broadcastRes.data.id;

    // 2️⃣ Buat stream
    const streamRes = await youtube.liveStreams.insert({
      auth: oauth2Client,
      part: 'snippet,cdn',
      requestBody: {
        snippet: { title: `${title} Stream` },
        cdn: { 
          format: '1080p',
          ingestionType: 'rtmp'
        }
      }
    });

    const streamId = streamRes.data.id;
    const ingestUrl = streamRes.data.cdn.ingestionInfo.ingestionAddress;
    const streamKey = streamRes.data.cdn.ingestionInfo.streamName;

    // 3️⃣ Bind broadcast dengan stream
    await youtube.liveBroadcasts.bind({
      auth: oauth2Client,
      part: 'id,contentDetails',
      id: broadcastId,
      streamId: streamId
    });

    res.json({ broadcastId, streamId, ingestUrl, streamKey });
  } catch (e) {
    console.error(e);
    res.status(500).send('Gagal membuat broadcast');
  }
});

// Endpoint untuk mengirim video ke RTMP ingest menggunakan FFmpeg
app.post('/start-stream/:streamKey', (req, res) => {
  const { streamKey } = req.params;
  const videoPath = path.resolve(__dirname, 'streams', 'sample.mp4');

  const ingestUrl = `rtmp://a.rtmp.youtube.com/live2/${streamKey}`;

  ffmpeg(videoPath)
    .outputOptions([
      '-c:v libx264',
      '-preset veryfast',
      '-maxrate 3000k',
      '-bufsize 6000k',
      '-pix_fmt yuv420p',
      '-g 50',
      '-c:a aac',
      '-b:a 160k',
      '-ar 44100',
      '-f flv'
    ])
    .on('start', cmd => console.log('FFmpeg started:', cmd))
    .on('error', err => {
      console.error('FFmpeg error:', err);
      res.status(500).send('Streaming error');
    })
    .on('end', () => {
      console.log('Streaming selesai');
      res.send('Streaming selesai');
    })
    .output(ingestUrl)
    .run();
});

app.listen(process.env.PORT, () => {
  console.log(`Server jalan di http://localhost:${process.env.PORT}`);
});

Kode di atas melakukan tiga hal utama: membuat broadcast, membuat stream (dapat URL ingest), meng‑bind keduanya, lalu menggunakan FFmpeg untuk meng‑stream file video ke URL RTMP YouTube. Pada prakteknya, kamu dapat mengganti sample.mp4 dengan webcam atau source lain.

4. Menjalankan Server

Pastikan semua variabel lingkungan terisi, lalu jalankan:

node index.js

Jika semuanya berjalan lancar, kamu akan melihat log “Server jalan di http://localhost:3000”. Sekarang kamu bisa mengirim request POST /create-broadcast dengan body JSON berisi title dan description menggunakan tools seperti Postman atau curl.

Integrasi dengan GitHub Actions untuk Otomatisasi

Tutorial Automation Katalon 08 - Integrasi dengan Git | Github (2024

1. Mengatur Secrets di Repository

Masuk ke halaman repo di GitHub → Settings → Secrets and variables → Actions → New repository secret. Tambahkan:

  • YOUTUBE_API_KEY
  • YOUTUBE_CLIENT_ID
  • YOUTUBE_CLIENT_SECRET
  • OAUTH_REDIRECT_URI (biasanya http://localhost:3000/oauth2callback)

Dengan menyimpan kredensial di sini, workflow tidak pernah mengekspos data sensitif.

2. Membuat Workflow File

Buat folder .github/workflows di repo, lalu file stream.yml dengan isi berikut:

name: Deploy & Stream YouTube

on:
  push:
    branches: [ main ]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout repository
      uses: actions/checkout@v3

    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '20'

    - name: Install dependencies
      run: npm ci

    - name: Run tests (optional)
      run: npm test || echo "No tests defined"

    - name: Deploy to Render (or any cloud)
      env:
        YOUTUBE_API_KEY: ${{ secrets.YOUTUBE_API_KEY }}
        YOUTUBE_CLIENT_ID: ${{ secrets.YOUTUBE_CLIENT_ID }}
        YOUTUBE_CLIENT_SECRET: ${{ secrets.YOUTUBE_CLIENT_SECRET }}
        PORT: 3000
      run: |
        # Contoh deployment ke Render.com
        curl -X POST -H "Authorization: Bearer ${{ secrets.RENDER_API_TOKEN }}" 
        -d '{"serviceId":"your-service-id"}' https://api.render.com/v1/services/deploy

Workflow ini akan otomatis meng‑install dependencies dan melakukan deploy setiap kali ada push ke main. Kamu dapat mengganti langkah Deploy dengan platform pilihan, seperti Heroku, Vercel, atau Railway.

3. Menghubungkan dengan Tutorial Lain

Jika kamu ingin melihat contoh praktis bagaimana GitHub Actions berinteraksi dengan YouTube Live, baca artikel Cara Menghubungkan YouTube Live dengan GitHub Actions: Otomatisasi Streaming yang Bikin Hidup Lebih Mudah!. Di sana dijelaskan cara menambahkan langkah ffmpeg ke dalam job CI sehingga video dapat langsung dipush ke YouTube setelah build selesai.

Deploy ke Platform Cloud (Opsional)

Heroku

Heroku masih menjadi pilihan yang mudah untuk Node.js. Buat file Procfile dengan isi:

web: node index.js

Lalu lakukan push ke Heroku remote:

heroku create nama-aplikasi
git push heroku main

Jangan lupa set environment variables di dashboard Heroku, mirip dengan yang kamu lakukan di GitHub Secrets.

Vercel

Vercel cocok untuk project yang “serverless”. Meskipun Vercel tidak mendukung proses long‑running seperti FFmpeg streaming secara native, kamu bisa memanfaatkan Vercel Serverless Functions untuk meng‑trigger stream ke layanan eksternal (misalnya AWS MediaLive). Jika ingin tetap memakai Vercel, pertimbangkan menaruh proses FFmpeg di worker terpisah, misalnya di AWS Lambda atau Google Cloud Run.

Render.com

Render menawarkan layanan “Web Service” yang mirip dengan Heroku, tetapi dengan pricing yang lebih bersahabat. Cukup hubungkan repo, pilih “Node.js”, dan Render akan otomatis meng‑install dependencies serta menjalankan perintah npm start (atau node index.js).

Tips & Trik Praktis untuk Streaming Lancar

Optimasi Bitrate

  • Gunakan bitrate video sekitar 2500‑3000 Kbps untuk 720p, dan 4500‑6000 Kbps untuk 1080p. Ini menjaga kualitas tanpa over‑load jaringan.
  • Sesuaikan -maxrate dan -bufsize di FFmpeg agar tidak terjadi “buffering”.

Menggunakan Hardware Encoder

Jika laptop kamu dilengkapi GPU modern (NVIDIA, AMD, atau Intel Quick Sync), tambahkan flag -c:v h264_nvenc (atau h264_qsv) di opsi FFmpeg. Ini mengurangi beban CPU secara signifikan.

Monitoring Live Stream

Gunakan endpoint YouTube Live Dashboard untuk melihat status broadcast secara real‑time. Selain itu, kamu dapat menambahkan endpoint health‑check di Express (misalnya /health) yang akan dipanggil oleh layanan monitoring seperti UptimeRobot.

Penyimpanan Video Lokal vs Cloud

Jika ingin menyimpan arsip streaming, tambahkan step di workflow yang men‑upload file hasil transcoding ke Google Cloud Storage atau Amazon S3 setelah proses selesai. Dengan begitu, kamu memiliki backup otomatis tanpa harus mengandalkan YouTube archive.

Keamanan API

Selalu gunakan OAuth 2.0 untuk operasi yang memerlukan hak akses menulis (misalnya membuat broadcast). Hindari menaruh API key di kode sumber, dan manfaatkan dotenv serta GitHub Secrets untuk menyimpan credential.

Itulah rangkaian lengkap dari persiapan hingga deployment streaming video YouTube dengan Node.js dan GitHub. Dengan mengikuti langkah-langkah di atas, kamu tidak hanya mendapatkan alur kerja yang terstruktur, tetapi juga menguasai teknik‑teknik penting seperti penggunaan FFmpeg, OAuth, dan CI/CD otomatis. Selamat mencoba, dan semoga streaming kamu selalu lancar, stabil, serta menarik banyak penonton!