A Go API application using TORM (TypeORM-inspired ORM) with PostgreSQL database.

• Docker
• Kubernetes cluster (local or remote)
• kubectl configured to access your cluster
• Go 1.23+ (for local development)

cd tf-api-TORM

# Make deployment script executable
chmod +x deploy.sh

# Run deployment
./deploy.sh

The service is exposed via a LoadBalancer. After running ./deploy.sh, it may take a minute for the external IP to be available.

You can check the status and find the EXTERNAL-IP by running:

kubectl get svc tf-api-torm -n tf-api-torm

Once the EXTERNAL-IP is assigned (for Docker Desktop, this will typically be localhost), you can access the API on port 80. For example:

# Visit the API (replace localhost if your EXTERNAL-IP is different)
curl http://localhost/v1/

The deployment includes:

• PostgreSQL Database: Persistent storage with ConfigMap and Secret management
• tf-api-TORM Application: Go API with TORM ORM integration
• Kubernetes Resources: Namespace, Deployments, Services, and Ingress

All Kubernetes resources are defined in a single file (k8s/deployment.yaml):

• Namespace: tf-api-torm namespace for isolation
• ConfigMaps: Database and application configuration
• Secrets: Database password and sensitive data
• PostgreSQL: Database deployment with persistent storage
• tf-api-TORM API: Application deployment with init containers
• Services: Internal communication between components
• Ingress: External access (commented out by default)

The application requires the following environment variables:

• DATABASE_URL: PostgreSQL connection string
• PRIVATE_KEY: JWT private key
• PUBLIC_KEY: JWT public key
• GMAIL_CLIENT_ID: Gmail OAuth client ID
• GMAIL_CLIENT_SECRET: Gmail OAuth client secret
• GMAIL_REFRESH_TOKEN: Gmail OAuth refresh token

Default database settings:

• Database: tfapi
• User: tfapi_user
• Password: tfapi_password

1. Start PostgreSQL:

docker run -d \
  --name postgres-tfapi \
  -e POSTGRES_DB=tfapi \
  -e POSTGRES_USER=tfapi_user \
  -e POSTGRES_PASSWORD=tfapi_password \
  -p 5432:5432 \
  postgres:15-alpine

2. Set environment variables:

export DATABASE_URL="postgresql://tfapi_user:tfapi_password@localhost:5432/tfapi?sslmode=disable"

3. Generate TORM models and run migrations:

chmod +x build.sh
./build.sh

4. Run the application:

go run main.go

docker build -t tf-api-torm:latest .

If you prefer to deploy manually:

# Build the Docker image
docker build -t tf-api-torm:latest .

# Apply the Kubernetes configuration
kubectl apply -f k8s/deployment.yaml

# Check the deployment status
kubectl get pods -n tf-api-torm

The API provides the following endpoints:

• GET /v1/get/projects - Get all projects
• GET /v1/get/project/{id} - Get specific project
• GET /v1/get/projects/{category} - Get projects by category
• POST /v1/post/vote - Submit a vote
• PUT /v1/update/verify_vote - Verify a vote

# Application logs
kubectl logs -f deployment/tf-api-torm -n tf-api-torm

# Database logs
kubectl logs -f deployment/postgres -n tf-api-torm

kubectl get pods -n tf-api-torm

kubectl get svc -n tf-api-torm

1. Database Connection Issues

   • Check if PostgreSQL pod is running: kubectl get pods -n tf-api-torm
   • Check database logs: kubectl logs deployment/postgres -n tf-api-torm

2. TORM Generation Issues

   • Ensure DATABASE_URL is correctly set
   • Check if TORM CLI is installed in the container
   • Verify database is accessible from the application pod

3. Application Startup Issues

   • Check application logs: kubectl logs deployment/tf-api-torm -n tf-api-torm
   • Verify all environment variables are set
   • Check if the application can connect to the database

To remove the entire deployment:

kubectl delete namespace tf-api-torm

• Update the default database password in production
• Store sensitive environment variables in Kubernetes Secrets
• Configure proper ingress rules for production use
• Enable SSL/TLS for database connections in production

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Test the deployment
5. Submit a pull request