Coolifyハンズオン：Hono・Go・Railsを実際にデプロイしてみる

import { Hono } from 'hono'
import { serve } from '@hono/node-server'

const app = new Hono()

app.get('/', (c) => {
  const now = new Date().toISOString()
  return c.html(`
    <h1>Hello from Hono on Coolify!</h1>
    <p>Current time: ${now}</p>
    <p>Node.js ${process.version}</p>
  `)
})

app.get('/health', (c) => {
  return c.json({ status: 'ok' })
})

const port = Number(process.env.PORT) || 3000
console.log(`Server running on port ${port}`)
serve({ fetch: app.fetch, port })

{
  "type": "module",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

coolify-demo-honoリポジトリをNixpacksでデプロイして。
ドメインはdemo-hono.teraren.comで。

╔══════════════ Nixpacks v1.41.0 ═══════════════╗
║ setup      │ nodejs_22, npm-9_x, curl, wget   ║
║────────────────────────────────────────────────║
║ install    │ npm ci                            ║
║────────────────────────────────────────────────║
║ build      │ npm run build                     ║
║────────────────────────────────────────────────║
║ start      │ npm run start                     ║
╚════════════════════════════════════════════════╝

package main

import (
  "encoding/json"
  "fmt"
  "net/http"
  "os"
  "runtime"
  "time"
)

func main() {
  port := os.Getenv("PORT")
  if port == "" {
    port = "8080"
  }

  hostname, _ := os.Hostname()

  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    fmt.Fprintf(w, "Hello from Go on Coolify!\n\nGo version: %s\nHostname:   %s\nTime:       %s\n",
      runtime.Version(), hostname, time.Now().Format(time.RFC3339))
  })

  http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
  })

  fmt.Printf("Listening on :%s\n", port)
  http.ListenAndServe(":"+port, nil)
}

# Build stage
FROM golang:1.24-alpine AS builder
WORKDIR /app
COPY go.mod .
COPY main.go .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o server .

# Production stage — tiny image with just the binary
FROM scratch
COPY --from=builder /app/server /server
EXPOSE 8080
ENTRYPOINT ["/server"]

coolify-demo-goリポジトリをDockerfileでデプロイして。
ドメインはdemo-go.teraren.comで。

services:
  app:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      - RAILS_ENV=production
      - DATABASE_HOST=db
      - DATABASE_USER=postgres
      - DATABASE_PASSWORD=password
      - REDIS_URL=redis://redis:6379/0
      - OLLAMA_URL=http://ollama:11434
      - SECRET_KEY_BASE=dummy-secret-key-for-demo-only
      - RAILS_LOG_TO_STDOUT=true
      - RAILS_SERVE_STATIC_FILES=true
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/up"]
      interval: 10s
      timeout: 5s
      retries: 3
      start_period: 30s

  db:
    image: postgres:17-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=app_production
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 3s
      retries: 5

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

volumes:
  postgres_data:
  redis_data:
  ollama_data:

class HomeController < ApplicationController
  def index
    @db_adapter = ActiveRecord::Base.connection.adapter_name
    @redis_status = check_redis
    @ollama_status, @ollama_models = check_ollama
    @messages = Message.order(created_at: :desc).limit(20).reverse
  end

  def chat
    prompt = params[:prompt].to_s.strip
    return redirect_to root_path if prompt.empty?

    Message.create!(role: "user", content: prompt)
    response = chat_with_ollama(prompt)
    Message.create!(role: "assistant", content: response)
    redirect_to root_path
  end

  private

  def chat_with_ollama(prompt)
    uri = URI("#{ENV['OLLAMA_URL']}/api/generate")
    body = { model: "tinyllama", prompt: prompt, stream: false }.to_json
    response = Net::HTTP.post(uri, body, "Content-Type" => "application/json")
    JSON.parse(response.body)["response"]
  rescue => e
    "Error: #{e.message}"
  end
end

FROM ruby:3.4-alpine AS base
WORKDIR /app
ENV RAILS_ENV=production BUNDLE_WITHOUT="development:test" BUNDLE_DEPLOYMENT=1

FROM base AS build
RUN apk add --no-cache build-base postgresql-dev curl yaml-dev
COPY Gemfile ./
RUN bundle lock && bundle install --jobs 4

COPY . .
RUN SECRET_KEY_BASE_DUMMY=1 bin/rails assets:precompile 2>/dev/null || true

FROM base AS runtime
RUN apk add --no-cache libpq curl tzdata yaml && adduser -D -h /app rails
COPY --from=build /usr/local/bundle /usr/local/bundle
COPY --from=build /app /app
RUN mkdir -p db storage log tmp/pids && chown -R rails:rails db storage log tmp
USER rails
EXPOSE 3000

CMD ["sh", "-c", "bin/rails db:prepare && bin/rails server -b 0.0.0.0 -p 3000"]

coolify-demo-railsリポジトリをDocker Composeでデプロイして。
appサービスのドメインはdemo-rails.teraren.comで。