13日間のクラウドスプリント：期限切れGCPクレジットを永続的なメンテナンス費用ゼロのアセットに変える方法

graph TD
    A["Ephemeral GCP Credits ($175)"] --"Funds"--> B
    subgraph "Ephemeral GCP Compute Engines"
        direction LR
        B1[Vertex AI<br/>Gemini 2.5 Pro & Flash]
        B2[Cloud Text-to-Speech<br/>Journey & Studio Voices]
        B3[GCE Spot GPUs<br/>NVIDIA L4/T4]
        B4[BigQuery<br/>Public Dataset Mining]
    end
    B = B1 & B2 & B3 & B4

    B --"Generates"--> C

    subgraph "Permanent Digital Artifacts"
        direction LR
        C1["In-depth Guides<br/>(Markdown/MDX)"]
        C2["Neural Audio Files<br/>(48kHz MP3s)"]
        C3["Pre-rendered Video<br/>(1080p MP4s)"]
        C4["Analytical Datasets<br/>(Parquet/DuckDB)"]
    end
    C = C1 & C2 & C3 & C4

    C --"Hosted on"--> D

    subgraph "$0/mo Permanent Hosting"
        direction LR
        D1["Git Repo<br/>(GitHub/GitLab)"]
        D2["Static Site Hosting<br/>(Vercel/Netlify)"]
        D3["Object Storage<br/>(Cloudflare R2)"]
        D4["Personal Backup<br/>(Google Drive via Rclone)"]
    end
    D = D1 & D2 & D3 & D4

# 1. Set up your project and variables
export PROJECT_ID="your-gcp-project-id"
export SA_NAME="asset-converter-sa"
export SA_EMAIL="${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com"

gcloud config set project ${PROJECT_ID}

# 2. Create the service account
gcloud iam service-accounts create ${SA_NAME} \
  --display-name="Service Account for Asset Conversion Sprint"

# 3. Grant minimal, specific IAM roles
# For Vertex AI Gemini access
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:${SA_EMAIL}" \
  --role="roles/aiplatform.user"

# For Cloud TTS and other service usage APIs
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:${SA_EMAIL}" \
  --role="roles/serviceusage.serviceUsageConsumer"

# For BigQuery access
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:${SA_EMAIL}" \
  --role="roles/bigquery.user"

# 4. Create and download the key file
gcloud iam service-accounts keys create "gcp_credentials.json" \
  --iam-account=${SA_EMAIL}

# 5. Set the environment variable for your scripts
export GOOGLE_APPLICATION_CREDENTIALS="$(pwd)/gcp_credentials.json"

echo "✅ Service account setup complete. Key saved to gcp_credentials.json"

# filename: generate_articles.py
import google.generativeai as genai
import os
from pathlib import Path

# IMPORTANT: This flag tells the SDK to use Vertex AI,
# which is billed to your GCP project and uses your credits.
genai.configure(vertexai=True)

# Configuration
MODEL_NAME = "gemini-2.5-flash" # Use Flash for speed/cost, Pro for quality
OUTPUT_DIR = Path("./generated_articles")
PROMPTS_FILE = "prompts.txt"
SYSTEM_PROMPT = """
You are an expert technical writer for a senior software engineering blog.
Your tone is deeply technical, precise, and practical.
When asked to write an article, provide a complete, well-structured markdown file.
Include code snippets with language tags where appropriate.
Do not include any preamble like "Here is the article you requested."
"""

def main():
    if not OUTPUT_DIR.exists():
        OUTPUT_DIR.mkdir()

    model = genai.GenerativeModel(MODEL_NAME, system_instruction=SYSTEM_PROMPT)

    with open(PROMPTS_FILE, "r") as f:
        prompts = [line.strip() for line in f if line.strip()]

    for i, prompt in enumerate(prompts):
        print(f"Generating article {i+1}/{len(prompts)} for prompt: '{prompt[:50]}...'")
        try:
            response = model.generate_content(prompt)
            
            # Create a filename-safe version of the prompt
            slug = "".join(c for c in prompt.lower() if c.isalnum() or c == ' ')
            slug = "-".join(slug.split())[:50]
            output_path = OUTPUT_DIR / f"{i+1:02d}-{slug}.md"

            with open(output_path, "w") as out_file:
                out_file.write(response.text)
            
            print(f"  -> Saved to {output_path}")

        except Exception as e:
            print(f"  -> ERROR generating article: {e}")

if __name__ == "__main__":
    main()

# filename: synthesize_audio.py
from google.cloud import texttospeech
import sys

def synthesize_text_to_audio(text_file_path: str, output_file_path: str):
    """Synthesizes speech from the input file of text."""
    
    client = texttospeech.TextToSpeechClient()

    with open(text_file_path, "r") as f:
        text_content = f.read()

    # The API has a 5000 byte limit per request. We'll just use the first 4900 bytes for this example.
    # A production script would chunk the text into multiple requests and stitch the audio.
    input_text = texttospeech.SynthesisInput(text=text_content[:4900])

    # Voice selection is critical. Journey voices are amazing.
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US", name="en-US-Journey-F"
    )

    # Audio configuration for high quality
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3,
        speaking_rate=0.95,
        effects_profile_id=['headphone-class-device'] # For crisp, clear audio
    )

    print(f"Synthesizing audio for {text_file_path}...")
    response = client.synthesize_speech(
        request={"input": input_text, "voice": voice, "audio_config": audio_config}
    )

    # The response's audio_content is binary.
    with open(output_file_path, "wb") as out:
        out.write(response.audio_content)
        print(f'Audio content written to file "{output_file_path}"')

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python synthesize_audio.py <input_text_file> <output_mp3_file>")
        sys.exit(1)
    
    synthesize_text_to_audio(sys.argv[1], sys.argv[2])

# Assumes you have a 'startup-script.sh' in your current directory
gcloud compute instances create gpu-spot-worker \
    --project=${PROJECT_ID} \
    --zone=us-central1-a \
    --machine-type=g2-standard-4 \
    --accelerator=type=nvidia-l4,count=1 \
    --provisioning-model=SPOT \
    --instance-termination-action=DELETE \
    --maintenance-policy=TERMINATE \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --boot-disk-size=50GB \
    --scopes=https://www.googleapis.com/auth/cloud-platform \
    --metadata-from-file=startup-script=./startup-script.sh

#!/bin/bash
echo "Startup script running!"

# Install necessary software (e.g., Blender, Python, CUDA drivers, rclone)
sudo apt-get update
sudo apt-get install -y blender unzip

# Install rclone
curl https://rclone.org/install.sh | sudo bash

# Rclone needs a config file. You can't run 'rclone config' interactively.
# The best way is to pre-create the rclone.conf on your local machine
# and pass it to the VM, for example via a GCS bucket or embedded here.
# For simplicity, let's assume it's fetched from a secure GCS bucket.
# gsutil cp gs://my-secure-bucket/rclone.conf /root/.config/rclone/rclone.conf

# --- YOUR COMPUTE-INTENSIVE BATCH JOB GOES HERE ---
# Example: Render a frame from a Blender project
# blender -b /path/to/project.blend -o /tmp/frame_### -f 1

# For this example, let's just create a dummy result file
echo "Batch job completed at $(date)" > /tmp/result.txt
mkdir -p /tmp/render_output
touch /tmp/render_output/frame_001.png
touch /tmp/render_output/frame_002.png

# --- SYNC RESULTS TO PERMANENT STORAGE ---
# This is the most important step. Sync data out before preemption.
# "GDrive" is the name of the remote you configured in rclone.
echo "Syncing results to Google Drive..."
rclone copy /tmp/render_output GDrive:GCP_Sprint_Output/$(date +%F-%H%M%S) -v

echo "Sync complete. Worker can now be terminated."

# The script ends, and the VM will be torn down on preemption or completion.