Berbagi Variabel Antara Skrip TypeScript dan Bash: Panduan Lengkap

Dalam pengembangan perangkat lunak modern, sering kali kita berurusan dengan lingkungan yang beragam, menggunakan berbagai bahasa dan teknologi untuk menyelesaikan tugas yang kompleks. Salah satu skenario umum adalah interaksi antara skrip TypeScript, yang sering digunakan untuk pengembangan frontend dan backend Node.js, dan skrip Bash, yang merupakan tulang punggung otomatisasi sistem dan operasi DevOps. Berbagi variabel antara kedua jenis skrip ini dapat menyederhanakan alur kerja, mengurangi redundansi, dan meningkatkan efisiensi. Artikel ini akan membahas berbagai teknik dan praktik terbaik untuk berbagi variabel antara skrip TypeScript dan Bash.

Mengapa Berbagi Variabel Penting?

Sebelum kita menyelami detail teknis, mari kita pahami mengapa berbagi variabel antara TypeScript dan Bash sangat berharga:

1. Automatisasi yang Disempurnakan: Automatiskan tugas-tugas yang kompleks yang melibatkan backend (TypeScript) dan operasi sistem (Bash) tanpa intervensi manual. Misalnya, skrip TypeScript dapat memicu deployment melalui skrip Bash, mengirimkan variabel konfigurasi yang diperlukan.
2. Konfigurasi Terpusat: Kelola konfigurasi aplikasi di satu tempat (misalnya, file TypeScript) dan bagikan dengan skrip Bash untuk konsistensi dan pemeliharaan yang mudah.
3. Integrasi Alur Kerja: Integrasikan skrip TypeScript dan Bash secara mulus ke dalam alur kerja pengembangan yang lebih luas, memungkinkan komunikasi dan koordinasi otomatis.
4. Reduksi Redundansi: Hindari mendefinisikan variabel yang sama di beberapa tempat, mengurangi potensi kesalahan dan menyederhanakan basis kode.
5. Fleksibilitas dan Portabilitas: Memungkinkan skrip TypeScript dan Bash untuk bekerja bersama dalam berbagai lingkungan, memastikan portabilitas dan adaptasi yang lebih baik.

Teknik Berbagi Variabel

Berikut adalah beberapa teknik yang dapat Anda gunakan untuk berbagi variabel antara skrip TypeScript dan Bash, dengan contoh kode dan penjelasan yang mendalam:

1. Variabel Lingkungan

Variabel lingkungan adalah cara yang paling sederhana dan sering digunakan untuk berbagi informasi antara proses yang berbeda. TypeScript dan Bash dapat mengakses dan memodifikasi variabel lingkungan.

TypeScript -> Bash

Dalam TypeScript, Anda dapat mengatur variabel lingkungan menggunakan process.env:

// TypeScript script (set-env.ts)
process.env.MY_VARIABLE = "Hello from TypeScript!";

console.log("Setting MY_VARIABLE in TypeScript");

Untuk menjalankan skrip TypeScript ini dan kemudian menjalankan skrip Bash, Anda dapat menggunakan:

#!/bin/bash

# Compile and run TypeScript
npx ts-node set-env.ts

# Access the variable in Bash
echo "MY_VARIABLE in Bash: $MY_VARIABLE"

Penjelasan:

1. Skrip TypeScript mengatur variabel lingkungan MY_VARIABLE.
2. Skrip Bash menjalankan skrip TypeScript menggunakan ts-node.
3. Skrip Bash kemudian mengakses variabel lingkungan MY_VARIABLE dan mencetaknya.

Bash -> TypeScript

Demikian pula, Anda dapat mengatur variabel lingkungan di Bash dan mengaksesnya di TypeScript:

#!/bin/bash

# Set the environment variable in Bash
export BASH_VARIABLE="Hello from Bash!"

# Run the TypeScript script
npx ts-node get-env.ts

// TypeScript script (get-env.ts)
const bashVariable = process.env.BASH_VARIABLE;

console.log("BASH_VARIABLE in TypeScript:", bashVariable);

Penjelasan:

1. Skrip Bash menetapkan variabel lingkungan BASH_VARIABLE menggunakan export.
2. Skrip Bash menjalankan skrip TypeScript menggunakan ts-node.
3. Skrip TypeScript mengakses variabel lingkungan BASH_VARIABLE menggunakan process.env dan mencetaknya.

Keuntungan:

• Sederhana dan mudah dipahami.
• Tidak memerlukan dependensi eksternal.

Kekurangan:

• Cocok untuk berbagi data kecil dan sederhana.
• Tidak ideal untuk berbagi struktur data kompleks.
• Variabel lingkungan bersifat global, yang dapat menyebabkan konflik jika tidak dikelola dengan hati-hati.

2. File .env (dengan dotenv)

File .env adalah file teks sederhana yang berisi variabel lingkungan. Pustaka `dotenv` memungkinkan Anda memuat variabel ini ke dalam `process.env` di TypeScript.

Konfigurasi

Pertama, instal `dotenv`:

npm install dotenv

Buat file `.env` di direktori proyek Anda:

# .env file
API_KEY=your_api_key
DATABASE_URL=your_database_url

TypeScript -> Bash (melalui .env)

// TypeScript script (generate-env.ts)
import * as fs from 'fs';

const apiKey = "new_api_key";
const databaseUrl = "new_database_url";

const envContent = `API_KEY=${apiKey}\nDATABASE_URL=${databaseUrl}`;

fs.writeFileSync('.env', envContent);

console.log("Generated .env file");

#!/bin/bash

# Run the TypeScript script to generate .env
npx ts-node generate-env.ts

# Load the .env file
source .env

# Access variables in Bash
echo "API_KEY in Bash: $API_KEY"
echo "DATABASE_URL in Bash: $DATABASE_URL"

Penjelasan:

1. Skrip TypeScript membuat file `.env` dengan variabel yang diinginkan.
2. Skrip Bash menjalankan skrip TypeScript untuk membuat file `.env`.
3. Skrip Bash menggunakan perintah `source .env` untuk memuat variabel dari file `.env` ke dalam lingkungan Bash.
4. Skrip Bash kemudian mengakses variabel yang dimuat.

Bash -> TypeScript (melalui .env)

#!/bin/bash

# Set variables in Bash
export API_KEY="bash_api_key"
export DATABASE_URL="bash_database_url"

# Create .env file
echo "API_KEY=$API_KEY" > .env
echo "DATABASE_URL=$DATABASE_URL" >> .env

# Run TypeScript script
npx ts-node use-env.ts

// TypeScript script (use-env.ts)
import * as dotenv from 'dotenv';
dotenv.config(); // Load variables from .env

const apiKey = process.env.API_KEY;
const databaseUrl = process.env.DATABASE_URL;

console.log("API_KEY in TypeScript:", apiKey);
console.log("DATABASE_URL in TypeScript:", databaseUrl);

Penjelasan:

1. Skrip Bash menetapkan variabel lingkungan dan kemudian menulisnya ke file `.env`.
2. Skrip Bash menjalankan skrip TypeScript.
3. Skrip TypeScript memuat variabel dari file `.env` menggunakan `dotenv.config()`.
4. Skrip TypeScript mengakses variabel lingkungan yang dimuat.

Keuntungan:

• Memisahkan konfigurasi dari kode.
• Cocok untuk mengelola banyak variabel konfigurasi.
• Dukungan luas dan praktik terbaik untuk aplikasi modern.

Kekurangan:

• Memerlukan dependensi eksternal (`dotenv`).
• Perlu mengelola file `.env` dengan hati-hati, terutama di lingkungan produksi.
• Tidak ideal untuk berbagi data sementara atau dinamis.

3. JSON (JavaScript Object Notation)

JSON adalah format data ringan yang mudah dibaca dan diuraikan oleh manusia. Ini sangat cocok untuk berbagi struktur data yang kompleks antara TypeScript dan Bash.

TypeScript -> Bash

// TypeScript script (generate-json.ts)
import * as fs from 'fs';

const data = {
  name: "My Application",
  version: "1.0.0",
  config: {
    apiUrl: "https://example.com/api",
    port: 8080,
  },
};

fs.writeFileSync('config.json', JSON.stringify(data, null, 2));

console.log("Generated config.json file");

#!/bin/bash

# Run the TypeScript script to generate JSON
npx ts-node generate-json.ts

# Parse JSON with jq
API_URL=$(jq -r '.config.apiUrl' config.json)
PORT=$(jq -r '.config.port' config.json)

echo "API_URL in Bash: $API_URL"
echo "PORT in Bash: $PORT"

Penjelasan:

1. Skrip TypeScript membuat objek JSON dan menulisnya ke file `config.json`.
2. Skrip Bash menjalankan skrip TypeScript untuk menghasilkan file JSON.
3. Skrip Bash menggunakan utilitas `jq` untuk menguraikan file JSON dan mengekstrak nilai.
4. Skrip Bash kemudian mengakses nilai yang diekstrak.

Bash -> TypeScript

#!/bin/bash

# Create JSON data in Bash
DATA='{"name": "My Application", "version": "1.0.0", "config": {"apiUrl": "https://example.com/api", "port": 8080}}'

# Write JSON to file
echo "$DATA" > config.json

# Run TypeScript script
npx ts-node use-json.ts

// TypeScript script (use-json.ts)
import * as fs from 'fs';

const jsonData = JSON.parse(fs.readFileSync('config.json', 'utf-8'));

console.log("API_URL in TypeScript:", jsonData.config.apiUrl);
console.log("PORT in TypeScript:", jsonData.config.port);

Penjelasan:

1. Skrip Bash membuat string JSON dan menulisnya ke file `config.json`.
2. Skrip Bash menjalankan skrip TypeScript.
3. Skrip TypeScript membaca file `config.json`, menguraikannya menggunakan `JSON.parse()`, dan mengakses nilai.

Keuntungan:

• Cocok untuk berbagi struktur data yang kompleks.
• Mudah dibaca dan diuraikan oleh mesin.
• Didukung secara luas di berbagai bahasa dan platform.

Kekurangan:

• Memerlukan utilitas eksternal seperti `jq` di Bash.
• Perlu menangani kesalahan penguraian JSON.
• Mungkin lebih berat daripada variabel lingkungan untuk data sederhana.

4. File Teks Sederhana (Data Dipisahkan)

Untuk data sederhana yang diformat secara terstruktur, Anda dapat menggunakan file teks sederhana dengan pemisah seperti koma (CSV) atau tab. Ini bisa menjadi alternatif yang lebih ringan daripada JSON.

TypeScript -> Bash

// TypeScript script (generate-csv.ts)
import * as fs from 'fs';

const data = [
  { name: "user1", id: 123, email: "user1@example.com" },
  { name: "user2", id: 456, email: "user2@example.com" },
];

const csvContent = data.map(row => `${row.name},${row.id},${row.email}`).join('\n');

fs.writeFileSync('data.csv', csvContent);

console.log("Generated data.csv file");

#!/bin/bash

# Run the TypeScript script to generate CSV
npx ts-node generate-csv.ts

# Read and parse CSV with awk
while IFS=',' read -r name id email; do
  echo "Name: $name, ID: $id, Email: $email"
done < data.csv

Penjelasan:

1. Skrip TypeScript membuat data CSV dan menulisnya ke file `data.csv`.
2. Skrip Bash menjalankan skrip TypeScript untuk menghasilkan file CSV.
3. Skrip Bash menggunakan utilitas `awk` untuk membaca dan menguraikan file CSV.
4. Skrip Bash kemudian memproses setiap baris data.

Bash -> TypeScript

#!/bin/bash

# Create CSV data in Bash
echo "user1,123,user1@example.com" > data.csv
echo "user2,456,user2@example.com" >> data.csv

# Run TypeScript script
npx ts-node use-csv.ts

// TypeScript script (use-csv.ts)
import * as fs from 'fs';

const csvData = fs.readFileSync('data.csv', 'utf-8');
const lines = csvData.split('\n');

lines.forEach(line => {
  const [name, id, email] = line.split(',');
  console.log(`Name: ${name}, ID: ${id}, Email: ${email}`);
});

Penjelasan:

1. Skrip Bash membuat data CSV dan menulisnya ke file `data.csv`.
2. Skrip Bash menjalankan skrip TypeScript.
3. Skrip TypeScript membaca file `data.csv`, membagi baris, dan membagi setiap baris menjadi kolom.
4. Skrip TypeScript kemudian memproses setiap kolom data.

Keuntungan:

• Sederhana dan ringan.
• Mudah dipahami dan diedit secara manual.
• Cocok untuk data tabular sederhana.

Kekurangan:

• Tidak cocok untuk struktur data yang kompleks.
• Perlu menangani pemisahan dan penguraian data secara manual.
• Tidak sefleksibel JSON atau variabel lingkungan.

5. Pipa dan Pengalihan

Anda dapat menggunakan pipa dan pengalihan untuk mengirim data langsung antara skrip TypeScript dan Bash tanpa menggunakan file perantara. Ini sangat berguna untuk berbagi data sementara atau streaming.

TypeScript -> Bash

// TypeScript script (generate-data.ts)
const data = "Hello from TypeScript!";
console.log(data);

#!/bin/bash

# Run TypeScript and pipe output to Bash
DATA=$(npx ts-node generate-data.ts)

echo "Data received in Bash: $DATA"

Penjelasan:

1. Skrip TypeScript mencetak data ke konsol.
2. Skrip Bash menjalankan skrip TypeScript dan menangkap output menggunakan substitusi perintah (`$(...)`).
3. Skrip Bash kemudian mengakses data yang ditangkap.

Bash -> TypeScript

#!/bin/bash

# Send data to TypeScript via pipe
echo "Hello from Bash!" | npx ts-node process-data.ts

// TypeScript script (process-data.ts)
process.stdin.on('data', data => {
  const bashData = data.toString().trim();
  console.log("Data received in TypeScript:", bashData);
});

Penjelasan:

1. Skrip Bash mengirim data ke input standar dari skrip TypeScript menggunakan pipa (`|`).
2. Skrip TypeScript mendengarkan data pada input standarnya menggunakan `process.stdin`.
3. Skrip TypeScript kemudian memproses data yang diterima.

Keuntungan:

• Tidak memerlukan file perantara.
• Cocok untuk berbagi data sementara atau streaming.
• Sederhana dan efisien untuk data kecil.

Kekurangan:

• Tidak cocok untuk struktur data yang kompleks.
• Perlu menangani encoding dan format data secara manual.
• Mungkin sulit untuk mengelola alur kerja yang kompleks.

6. Socket (Komunikasi Jaringan)

Untuk komunikasi yang lebih kompleks dan waktu nyata, Anda dapat menggunakan soket untuk membuat koneksi jaringan antara skrip TypeScript dan Bash. Ini memungkinkan komunikasi dua arah dan berbagi data yang kompleks.

Karena kompleksitas implementasinya, contoh lengkap untuk menggunakan soket di luar cakupan artikel ini, tetapi konsepnya adalah sebagai berikut:

1. Server TypeScript: Skrip TypeScript bertindak sebagai server, mendengarkan koneksi masuk pada port tertentu.
2. Klien Bash: Skrip Bash bertindak sebagai klien, menghubungkan ke server TypeScript.
3. Pertukaran Data: Klien dan server dapat bertukar data melalui soket menggunakan protokol seperti JSON atau teks sederhana.

Pustaka seperti `net` di Node.js dapat digunakan untuk mengimplementasikan server soket di TypeScript, dan alat seperti `netcat` (nc) dapat digunakan untuk membuat koneksi soket dari Bash.

Keuntungan:

• Komunikasi dua arah.
• Cocok untuk berbagi data yang kompleks dan waktu nyata.
• Fleksibilitas tinggi dan kontrol atas protokol komunikasi.

Kekurangan:

• Kompleksitas implementasi tinggi.
• Perlu menangani manajemen koneksi, penanganan kesalahan, dan keamanan.
• Overhead performa yang lebih tinggi dibandingkan dengan metode lain.

Praktik Terbaik untuk Berbagi Variabel

Berikut adalah beberapa praktik terbaik yang perlu diingat saat berbagi variabel antara skrip TypeScript dan Bash:

1. Pilih Teknik yang Tepat: Pertimbangkan kompleksitas data, frekuensi berbagi, dan persyaratan performa saat memilih teknik berbagi variabel.
2. Konsisten: Gunakan konvensi penamaan yang konsisten untuk variabel untuk menghindari kebingungan dan kesalahan.
3. Validasi Data: Validasi data yang diterima dari skrip lain untuk memastikan integritas dan mencegah kerentanan keamanan.
4. Penanganan Kesalahan: Implementasikan penanganan kesalahan yang tepat untuk menangani kesalahan penguraian, kesalahan koneksi, dan masalah lainnya.
5. Keamanan: Hindari menyimpan informasi sensitif (seperti kata sandi atau kunci API) langsung dalam skrip atau file konfigurasi. Gunakan variabel lingkungan atau sistem manajemen rahasia untuk menangani data sensitif dengan aman.
6. Dokumentasi: Dokumentasikan proses berbagi variabel, termasuk format data, teknik yang digunakan, dan praktik terbaik keamanan.
7. Modularitas: Pertimbangkan untuk memodulasi logika berbagi variabel ke dalam fungsi atau modul terpisah untuk meningkatkan keterbacaan dan pemeliharaan.
8. Uji: Uji secara menyeluruh proses berbagi variabel untuk memastikan bahwa data ditransfer dengan benar dan bahwa semua penanganan kesalahan berfungsi seperti yang diharapkan.
9. Hindari Variabel Global yang Berlebihan: Minimalkan penggunaan variabel lingkungan global untuk menghindari konflik dan meningkatkan prediktabilitas kode.
10. Bersihkan Sumber Daya: Jika menggunakan soket atau sumber daya jaringan lainnya, pastikan untuk melepaskan atau menutupnya dengan benar setelah selesai menggunakannya.

Contoh Kasus: Alur Deployment

Mari kita pertimbangkan contoh kasus praktis di mana berbagi variabel antara TypeScript dan Bash sangat bermanfaat: alur deployment.

Skenario:

Anda memiliki aplikasi Node.js (TypeScript) yang perlu di-deploy ke server. Proses deployment melibatkan langkah-langkah berikut:

1. Bangun aplikasi TypeScript.
2. Transfer artefak build ke server.
3. Hentikan instance aplikasi yang sedang berjalan.
4. Deploy artefak build baru.
5. Mulai instance aplikasi baru.
6. Update konfigurasi sistem (jika diperlukan).

Anda dapat mengotomatiskan proses ini dengan menggabungkan skrip TypeScript dan Bash:

1. Skrip TypeScript (deploy.ts): Skrip ini bertanggung jawab untuk membangun aplikasi TypeScript dan mengumpulkan artefak build. Itu juga menentukan variabel konfigurasi penting seperti jalur server, port aplikasi, dan kredensial deployment.
2. Skrip Bash (deploy.sh): Skrip ini bertanggung jawab untuk mentransfer artefak build ke server, menghentikan dan memulai aplikasi, dan memperbarui konfigurasi sistem. Ia menerima variabel konfigurasi dari skrip TypeScript.

Berikut adalah bagaimana Anda dapat menerapkan ini menggunakan JSON untuk berbagi variabel:

// TypeScript script (deploy.ts)
import * as fs from 'fs';

const config = {
  serverPath: "/opt/app",
  appPort: 3000,
  deployUser: "deploy",
  buildDir: "dist",
};

fs.writeFileSync('deploy_config.json', JSON.stringify(config, null, 2));

console.log("Generated deploy_config.json");

// Build the application
// ... build logic ...

#!/bin/bash

# Run TypeScript script to generate config
npx ts-node deploy.ts

# Load config from JSON
SERVER_PATH=$(jq -r '.serverPath' deploy_config.json)
APP_PORT=$(jq -r '.appPort' deploy_config.json)
DEPLOY_USER=$(jq -r '.deployUser' deploy_config.json)
BUILD_DIR=$(jq -r '.buildDir' deploy_config.json)

# Transfer artifacts to server
scp -r $BUILD_DIR $DEPLOY_USER@$SERVER_PATH

# Stop the application
ssh $DEPLOY_USER@$SERVER_PATH "pm2 stop app"

# Deploy new artifacts
ssh $DEPLOY_USER@$SERVER_PATH "mv $SERVER_PATH/$BUILD_DIR/* $SERVER_PATH/"

# Start the application
ssh $DEPLOY_USER@$SERVER_PATH "pm2 start app --port $APP_PORT"

echo "Deployment completed successfully!"

Penjelasan:

1. Skrip TypeScript menghasilkan file JSON dengan konfigurasi deployment.
2. Skrip Bash memuat konfigurasi dari file JSON.
3. Skrip Bash menggunakan variabel konfigurasi untuk mentransfer artefak, menghentikan, dan memulai aplikasi di server.

Dengan membagikan variabel antara skrip TypeScript dan Bash, Anda dapat membuat alur deployment otomatis yang efisien dan bebas kesalahan.

Kesimpulan

Berbagi variabel antara skrip TypeScript dan Bash adalah teknik yang berharga untuk mengotomatiskan alur kerja, mengurangi redundansi, dan meningkatkan efisiensi. Dengan memahami berbagai teknik dan praktik terbaik yang dibahas dalam artikel ini, Anda dapat memilih pendekatan yang paling sesuai untuk kebutuhan spesifik Anda dan membangun integrasi yang kuat dan terpelihara antara TypeScript dan Bash.

Baik Anda memilih variabel lingkungan, file `.env`, JSON, file teks sederhana, pipa, atau soket, pastikan untuk memprioritaskan keamanan, validasi data, dan penanganan kesalahan untuk memastikan integrasi yang andal dan aman. Dengan perencanaan dan implementasi yang cermat, Anda dapat memanfaatkan kekuatan TypeScript dan Bash untuk mencapai tujuan pengembangan dan operasi Anda.

Ingatlah untuk mendokumentasikan alur kerja berbagi variabel Anda dengan jelas untuk memastikan pemeliharaan yang mudah dan pemahaman yang lebih baik oleh orang lain yang bekerja di proyek tersebut. Selamat berkarya!