deployml-core 0.0.57__tar.gz → 0.0.59__tar.gz

{deployml_core-0.0.57 → deployml_core-0.0.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deployml-core
-Version: 0.0.57
+Version: 0.0.59
 Summary: Infra for academia
 License-File: LICENSE
 Author: Drew Hoang

{deployml_core-0.0.57 → deployml_core-0.0.59}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "deployml-core"
-version = "0.0.57"
+version = "0.0.59"
 description = "Infra for academia"
 authors = [
     {name = "Drew Hoang", email = "codentell@gmail.com"},

{deployml_core-0.0.57 → deployml_core-0.0.59}/src/deployml/cli/cli.py

@@ -788,6 +788,9 @@ def deploy(
     generate_only: bool = typer.Option(
         False, "--generate-only", "-g", help="Only generate manifests, do not apply (for GKE deployments)"
     ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Stream Terraform logs to stdout instead of showing progress bar"
+    ),
 ):
     """
     Deploy infrastructure based on a YAML configuration file.
@@ -1027,6 +1030,34 @@ def deploy(
 
     typer.echo(f" Unified bucket creation: {create_artifact_bucket}")
 
+    # Auto-resolve image URIs: if a service image is not specified in the config (or still
+    # points to a legacy gcr.io path), derive it from the Artifact Registry path that
+    # `deployml build-images` produces: {region}-docker.pkg.dev/{project}/mlops-images/{name}
+    # This keeps the YAML config free of hardcoded image URIs — project/region are enough.
+    _TOOL_IMAGE_NAMES = {
+        "mlflow": "mlflow",
+        "feast": "feast",
+        "fastapi": "fastapi",
+        "grafana": "grafana-container",
+        "wandb": "wandb",
+    }
+    _ar_base = f"{region}-docker.pkg.dev/{project_id}/mlops-images"
+    for stage in stack:
+        for stage_name, tool in stage.items():
+            tool_name = tool.get("name", "")
+            params = tool.setdefault("params", {})
+            existing_image = params.get("image", "")
+            if not existing_image or existing_image.startswith("gcr.io/"):
+                image_name = _TOOL_IMAGE_NAMES.get(tool_name)
+                if image_name:
+                    params["image"] = f"{_ar_base}/{image_name}:latest"
+            # Cron job images are per-job and must be set explicitly — skip here
+            if stage_name == "workflow_orchestration" and tool_name == "cron":
+                for job in params.get("jobs", []):
+                    if not job.get("image") or job.get("image", "").startswith("gcr.io/"):
+                        job_name = job.get("service_name", "")
+                        job["image"] = f"{_ar_base}/{job_name}:latest"
+
     env = Environment(loader=FileSystemLoader(TEMPLATE_DIR))
     # PATCH: Use wandb_main.tf.j2 or mlflow_main.tf.j2 for cloud_run if present
     if deployment_type == "cloud_run":
@@ -1253,6 +1284,7 @@ def deploy(
             ["terraform", "apply", "-auto-approve"],
             DEPLOYML_TERRAFORM_DIR,
             minutes,
+            verbose=verbose,
         )
         if result_code == 0:
             typer.echo(" Deployment complete!")
@@ -1421,6 +1453,84 @@ def deploy(
         typer.echo(" Deployment cancelled")
 
 
+@cli.command()
+def get_urls(
+    config_path: Path = typer.Option(
+        ..., "--config-path", "-c", help="Path to YAML config file"
+    ),
+    env_path: Path = typer.Option(
+        Path(".env"), "--env-path", help="Path to write .env file"
+    ),
+):
+    """
+    Print service URLs from the last deployment and write them to a .env file.
+    """
+    if not config_path.exists():
+        typer.echo(f" Config file not found: {config_path}")
+        raise typer.Exit(code=1)
+
+    config = yaml.safe_load(config_path.read_text())
+    workspace_name = config.get("name") or "development"
+    terraform_dir = Path.cwd() / ".deployml" / workspace_name / "terraform"
+
+    if not terraform_dir.exists():
+        typer.echo(f" No deployment found at {terraform_dir}. Run 'deployml deploy' first.")
+        raise typer.Exit(code=1)
+
+    output_proc = subprocess.run(
+        ["terraform", "output", "-json"],
+        cwd=terraform_dir,
+        capture_output=True,
+        text=True,
+    )
+    if output_proc.returncode != 0:
+        typer.echo(" Could not retrieve Terraform outputs. Is the stack deployed?")
+        raise typer.Exit(code=1)
+
+    try:
+        outputs = json.loads(output_proc.stdout)
+    except Exception:
+        typer.echo(" Failed to parse Terraform outputs.")
+        raise typer.Exit(code=1)
+
+    if not outputs:
+        typer.echo("No outputs found. Is the stack deployed?")
+        raise typer.Exit(code=1)
+
+    typer.echo("\n DeployML Outputs:")
+    env_lines = []
+    for key, value in outputs.items():
+        is_sensitive = value.get("sensitive", False)
+        output_val = value.get("value")
+        env_key = key.upper()
+        if is_sensitive:
+            typer.secho(f"  {key}: [SENSITIVE] (value hidden)", fg=typer.colors.YELLOW)
+        elif isinstance(output_val, str):
+            if output_val.startswith("http://") or output_val.startswith("https://"):
+                typer.secho(f"  {key}: {output_val}", fg=typer.colors.BRIGHT_BLUE, bold=True)
+                env_lines.append(f"{env_key}={output_val}")
+            elif output_val == "":
+                typer.secho(f"  {key}: [No value]", fg=typer.colors.YELLOW)
+            else:
+                typer.echo(f"  {key}: {output_val}")
+                env_lines.append(f"{env_key}={output_val}")
+        elif isinstance(output_val, dict):
+            typer.echo(f"  {key}:")
+            for subkey, subval in output_val.items():
+                sub_env_key = f"{env_key}_{subkey.upper()}"
+                if isinstance(subval, str) and (subval.startswith("http://") or subval.startswith("https://")):
+                    typer.secho(f"    {subkey}: {subval}", fg=typer.colors.BRIGHT_BLUE, bold=True)
+                    env_lines.append(f"{sub_env_key}={subval}")
+                elif isinstance(subval, str) and subval:
+                    typer.echo(f"    {subkey}: {subval}")
+                    env_lines.append(f"{sub_env_key}={subval}")
+        else:
+            typer.echo(f"  {key}: {output_val}")
+
+    env_path.write_text("\n".join(env_lines) + "\n")
+    typer.echo(f"\n .env written to {env_path.resolve()}")
+
+
 @cli.command()
 def destroy(
     config_path: Path = typer.Option(
@@ -1487,16 +1597,53 @@ def destroy(
             cwd=DEPLOYML_TERRAFORM_DIR,
         )
 
-        # Check if we have Cloud SQL resources and clean them up first
-        plan_result = subprocess.run(
-            ["terraform", "plan", "-destroy"],
+        # Shut down Cloud Run services first to close any open DB connections
+        # before attempting to destroy Cloud SQL — otherwise active connections
+        # prevent database/user deletion and the destroy fails.
+        region = config.get("provider", {}).get("region", "us-central1")
+        cr_result = subprocess.run(
+            ["gcloud", "run", "services", "list",
+             "--project", project_id,
+             "--region", region,
+             "--format", "value(metadata.name)"],
+            capture_output=True, text=True
+        )
+        if cr_result.returncode == 0:
+            services = [s.strip() for s in cr_result.stdout.splitlines() if s.strip()]
+            for service in services:
+                typer.echo(f" Deleting Cloud Run service: {service}")
+                subprocess.run(
+                    ["gcloud", "run", "services", "delete", service,
+                     "--project", project_id,
+                     "--region", region,
+                     "--quiet"],
+                    capture_output=True,
+                )
+
+        # Remove Cloud SQL databases and user from Terraform state so Terraform
+        # doesn't try to delete them individually — the instance deletion handles
+        # that automatically, avoiding active-connection errors on destroy.
+        state_result = subprocess.run(
+            ["terraform", "state", "list"],
             cwd=DEPLOYML_TERRAFORM_DIR,
             capture_output=True,
             text=True,
         )
-
-        if "google_sql_database_instance" in plan_result.stdout:
-            cleanup_cloud_sql_resources(DEPLOYML_TERRAFORM_DIR, project_id)
+        if state_result.returncode == 0:
+            resources_to_remove = [
+                r.strip() for r in state_result.stdout.splitlines()
+                if any(x in r for x in [
+                    "google_sql_database.",
+                    "google_sql_user.",
+                ])
+            ]
+            for resource in resources_to_remove:
+                typer.echo(f" Removing from state: {resource}")
+                subprocess.run(
+                    ["terraform", "state", "rm", resource],
+                    cwd=DEPLOYML_TERRAFORM_DIR,
+                    capture_output=True,
+                )
 
         # Build destroy command
         cmd = ["terraform", "destroy", "--auto-approve"]

deployml_core-0.0.59/src/deployml/docker/fastapi/.dockerignore

@@ -0,0 +1,11 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv
+.git
+.gitignore
+README.md

deployml_core-0.0.59/src/deployml/docker/fastapi/Dockerfile

@@ -0,0 +1,38 @@
+# Build for Linux/amd64 platform (not Apple Silicon)
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY main.py .
+
+# Create non-root user
+RUN useradd -m -s /bin/bash fastapi && \
+    chown -R fastapi:fastapi /app
+
+# Switch to non-root user
+USER fastapi
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the application
+# Uses PORT env var so it works on Cloud Run (PORT=8080) and locally (PORT=8000)
+CMD uvicorn main:app --host 0.0.0.0 --port ${PORT:-8000}

deployml_core-0.0.59/src/deployml/docker/fastapi/main.py

@@ -0,0 +1,127 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import os
+from datetime import datetime
+import pandas as pd
+import mlflow
+import mlflow.pyfunc
+
+app = FastAPI(
+    title="FastAPI Demo",
+    description="Simple FastAPI application for Kubernetes deployment demo",
+    version="1.0.0"
+)
+
+# MLflow configuration — override via MLFLOW_TRACKING_URI env var
+MLFLOW_TRACKING_URI = os.getenv("MLFLOW_TRACKING_URI", "http://mlflow-service:5000")
+MODEL_NAME = os.getenv("MODEL_NAME", "HousingPriceModel")
+
+# Global model variable
+model = None
+
+# Pydantic models
+class PredictionRequest(BaseModel):
+    features: Dict[str, float]
+
+class PredictionResponse(BaseModel):
+    prediction: float
+    timestamp: str
+    model_used: Optional[str] = None
+
+class HealthResponse(BaseModel):
+    status: str
+    timestamp: str
+    port: int
+    mlflow_connected: bool
+    model_loaded: bool
+
+def load_model_from_mlflow():
+    """Load model from MLflow Model Registry"""
+    global model
+    
+    try:
+        mlflow.set_tracking_uri(MLFLOW_TRACKING_URI)
+        model = mlflow.pyfunc.load_model(f"models:/{MODEL_NAME}/Production")
+        print(f"✓ Loaded model '{MODEL_NAME}' from Production stage")
+        return True
+    except Exception as e:
+        print(f"⚠️  Could not load model from MLflow: {e}")
+        model = None
+        return False
+
+# Load model at startup
+@app.on_event("startup")
+async def startup_event():
+    """Load MLflow model on startup"""
+    load_model_from_mlflow()
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "service": "FastAPI Demo",
+        "version": "1.0.0",
+        "model_loaded": model is not None,
+        "model_name": MODEL_NAME,
+        "mlflow_uri": MLFLOW_TRACKING_URI,
+        "endpoints": {
+            "health": "/health",
+            "predict": "/predict",
+            "docs": "/docs"
+        }
+    }
+
+@app.get("/health", response_model=HealthResponse)
+async def health():
+    """Health check endpoint"""
+    port = int(os.getenv("FASTAPI_PORT", "8000"))
+    return HealthResponse(
+        status="healthy",
+        timestamp=datetime.now().isoformat(),
+        port=port,
+        mlflow_connected=True,
+        model_loaded=model is not None
+    )
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(request: PredictionRequest):
+    """Prediction endpoint using MLflow model"""
+    global model
+    
+    # If model is not loaded, return -1
+    if model is None:
+        return PredictionResponse(
+            prediction=-1.0,
+            timestamp=datetime.now().isoformat(),
+            model_used=None
+        )
+    
+    try:
+        # Convert features dict to DataFrame in correct order
+        # Features: bedrooms, bathrooms, area_sqft, lot_size, year_built, city, state
+        feature_order = ['bedrooms', 'bathrooms', 'area_sqft', 'lot_size', 'year_built', 'city', 'state']
+        feature_values = [request.features.get(f, 0.0) for f in feature_order]
+        X = pd.DataFrame([feature_values], columns=feature_order)
+        
+        prediction = float(model.predict(X)[0])
+        model_used = f"MLflow: {MODEL_NAME}"
+        
+        return PredictionResponse(
+            prediction=prediction,
+            timestamp=datetime.now().isoformat(),
+            model_used=model_used
+        )
+    except Exception as e:
+        # On any error, return -1
+        return PredictionResponse(
+            prediction=-1.0,
+            timestamp=datetime.now().isoformat(),
+            model_used=None
+        )
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("FASTAPI_PORT", "8000"))
+    uvicorn.run(app, host="0.0.0.0", port=port)

deployml_core-0.0.59/src/deployml/docker/fastapi/requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.5.2
+mlflow>=2.8.0
+scikit-learn>=1.0.0
+pandas>=1.3.0
+numpy>=1.21.0

deployml_core-0.0.59/src/deployml/docker/grafana-container/Dockerfile

@@ -0,0 +1,23 @@
+FROM grafana/grafana:10.4.5
+
+# Switch to root to copy files and change permissions
+USER root
+
+# Configure Grafana to listen on Cloud Run's expected port
+ENV GF_SERVER_HTTP_PORT=8080 \
+    GF_SECURITY_ADMIN_USER=admin \
+    GF_SECURITY_ADMIN_PASSWORD=admin
+
+# Copy entrypoint script and set permissions 
+COPY entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod 755 /usr/local/bin/entrypoint.sh
+
+# Create provisioning directories
+RUN mkdir -p /etc/grafana/provisioning/datasources \
+    /etc/grafana/provisioning/dashboards
+
+# Switch back to the default grafana user for runtime
+USER grafana
+
+# Set custom entrypoint
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

deployml_core-0.0.59/src/deployml/docker/grafana-container/README.md

@@ -0,0 +1,3 @@
+docker build --platform=linux/amd64 -t gcr.io/mlops-intro-461805/grafana/grafana:latest .
+
+docker push gcr.io/mlops-intro-461805/grafana/grafana:latest

deployml_core-0.0.59/src/deployml/docker/grafana-container/entrypoint.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env sh
+set -e
+
+# Map Cloud Run's PORT → Grafana's expected var
+export GF_SERVER_HTTP_PORT="${PORT:-${GF_SERVER_HTTP_PORT:-8080}}"
+
+echo "Starting Grafana on port ${GF_SERVER_HTTP_PORT}..."
+[ -n "${GF_DATABASE_URL:-}" ] && echo "Using database: ${GF_DATABASE_URL}"
+
+exec /run.sh

deployml_core-0.0.59/src/deployml/docker/mlflow/Dockerfile

@@ -0,0 +1,40 @@
+# Build for Linux/amd64 platform (not Apple Silicon)
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create non-root user
+RUN useradd -m -s /bin/bash mlflow && \
+    chown -R mlflow:mlflow /app
+
+# Create directories for MLflow data
+RUN mkdir -p /mlflow-artifacts && \
+    chown -R mlflow:mlflow /mlflow-artifacts
+
+# Switch to non-root user
+USER mlflow
+
+# Expose port
+EXPOSE 5000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:5000/health || exit 1
+
+# Default command - MLflow server
+# Uses PORT env var so it works on Cloud Run (PORT=8080) and locally (PORT=5000)
+CMD mlflow server --host 0.0.0.0 --port ${PORT:-5000} --dev
+

deployml_core-0.0.59/src/deployml/docker/mlflow/requirements.txt

@@ -0,0 +1,4 @@
+mlflow==3.10.0 
+psycopg2-binary 
+boto3 
+google-cloud-storage