Skip to main content Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-baas-railway-extO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Mais deste repositório Enterprise database architecture specialist with PostgreSQL 17, MySQL 8.4 LTS,
MongoDB 8.0, Redis 7.4 expertise. Master connection pooling, query optimization,
caching strategies, and database DevOps automation. Build scalable, resilient
database systems with comprehensive monitoring and disaster recovery.
Enterprise Frontend Development with AI-powered modern architecture, Context7 integration, and intelligent component orchestration for scalable user interfaces
Enterprise-grade security expertise with production-ready patterns for OWASP Top 10 2021, zero-trust architecture, threat modeling (STRIDE, PASTA), secure SDLC, DevSecOps automation, cloud security, cryptography, identity & access management, and compliance frameworks (SOC 2, ISO 27001, GDPR, CCPA).
Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
name moai-baas-railway-ext version 4.0.0 created 2025-11-11T00:00:00.000Z updated 2025-11-13T00:00:00.000Z status stable description Enterprise Railway Full-Stack Platform with AI-powered container orchestration, Context7 integration, and intelligent deployment automation for scalable modern applications keywords ["railway","full-stack","container-deployment","ci-cd","database-provisioning","auto-scaling","context7-integration","ai-orchestration","production-deployment"] allowed-tools ["Read","Bash","Write","Edit","Glob","Grep","WebFetch","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"]
Enterprise Railway Full-Stack Platform Expert v4.0.0
Skill Metadata
Field Value Skill Name moai-baas-railway-ext Version 4.0.0 (2025-11-13) Tier Enterprise Deployment Platform Expert AI-Powered ✅ Context7 Integration, Intelligent Architecture Auto-load On demand when Railway keywords detected
What It Does
Enterprise Railway Full-Stack Platform expert with AI-powered container orchestration, Context7 integration, and intelligent deployment automation for scalable modern applications.
Revolutionary v4.0.0 capabilities :
🤖 AI-Powered Railway Architecture using Context7 MCP for latest deployment patterns
📊 Intelligent Container Orchestration with automated scaling and optimization
🚀 Real-time Performance Analytics with AI-driven deployment insights
🔗 Enterprise CI/CD Integration with zero-configuration pipeline automation
📈 Predictive Cost Analysis with usage forecasting and resource optimization
When to Use
Automatic triggers :
Railway deployment architecture and container orchestration discussions
Full-stack application development and database integration
CI/CD pipeline setup and automated deployment strategies
Multi-region deployment and scaling optimization
Manual invocation :
Designing enterprise Railway architectures with optimal container configuration
Implementing automated CI/CD pipelines with GitHub integration
Planning full-stack application migrations to Railway
Optimizing costs and auto-scaling configuration
Quick Reference (Level 1)
Railway Full-Stack Platform (November 2025)
Core Features Overview
Container Deployment : Docker container deployment from GitHubDatabase Provisioning : PostgreSQL, MongoDB, Redis with automatic setup
Multi-Region Deployment
Git-Based CI/CD : Automated deployments from Git commits
Background Jobs : Scheduled tasks and job processing
One-Click Rollback : Instant deployment history and rollback
Supported Services
Applications : Node.js, Python, Ruby, Go, Rust, Java, PHPDatabases : PostgreSQL, MongoDB, Redis, MySQLStatic Sites : Next.js, React, Vue, Angular, HugoBackground Workers : Bull queue, Celery, Sidekiq integrationFile Storage : Integrated with cloud storage providers
Key Benefits
Zero Infrastructure Management : No server configuration requiredDeveloper-Friendly : Focus on code, not deployment complexityAuto-Scaling : Automatic scaling based on traffic and loadCost Controls : Built-in spending limits and monitoring
Performance Characteristics
Cold Start : < 2 seconds for container spin-upScaling : Instant horizontal and vertical scalingDatabase Performance : Optimized configurations for each database typeGlobal Latency : < 50ms in major regions
Core Implementation (Level 2)
Railway Architecture Intelligence
class RailwayArchitectOptimizer :
def __init__ (self ):
self .context7_client = Context7Client()
self .container_analyzer = ContainerAnalyzer()
self .scaling_optimizer = ScalingOptimizer()
async def design_optimal_railway_architecture (self,
requirements: ApplicationRequirements ) -> RailwayArchitecture:
"""Design optimal Railway architecture using AI analysis."""
railway_docs = await self .context7_client.get_library_docs(
context7_library_id='/railway/docs' ,
topic="container deployment ci-cd scaling optimization 2025" ,
tokens=3000
)
containerization_docs = await self .context7_client.get_library_docs(
context7_library_id='/docker/docs' ,
topic="optimization best practices orchestration 2025" ,
tokens=2000
)
container_optimization = self .container_analyzer.optimize_configuration(
requirements.application_stack,
containerization_docs
)
scaling_strategy = self .scaling_optimizer.design_scaling_strategy(
requirements.traffic_patterns,
requirements.performance_requirements,
railway_docs
)
return RailwayArchitecture(
application_services=self ._design_application_services(requirements),
database_services=self ._design_database_services(requirements),
container_configuration=container_optimization,
scaling_strategy=scaling_strategy,
deployment_pipeline=self ._design_cicd_pipeline(requirements),
monitoring_setup=self ._setup_monitoring(),
cost_analysis=self ._analyze_pricing_model(requirements)
)
Multi-Service Deployment Configuration
version: "1.0"
services:
frontend:
build:
dockerfile: Dockerfile.frontend
context: .
environment:
- NEXT_PUBLIC_API_URL=${API_URL}
- NODE_ENV=production
deploy:
replicas: 2
memory: 512Mi
cpu: 0.5
healthcheck:
test: ["CMD" , "curl" , "-f" , "http://localhost:3000/health" ]
interval: 30s
timeout: 10s
retries: 3
backend:
build:
dockerfile: Dockerfile.backend
context: .
environment:
- DATABASE_URL=${DATABASE_URL}
- REDIS_URL=${REDIS_URL}
- JWT_SECRET=${JWT_SECRET}
deploy:
replicas: 3
memory: 1Gi
cpu: 1.0
healthcheck:
test: ["CMD" , "curl" , "-f" , "http://localhost:8000/api/health" ]
interval: 30s
timeout: 10s
retries: 3
worker:
build:
dockerfile: Dockerfile.worker
context: .
environment:
- DATABASE_URL=${DATABASE_URL}
- REDIS_URL=${REDIS_URL}
deploy:
replicas: 1
memory: 512Mi
cpu: 0.5
postgres:
image: "postgres:16-alpine"
environment:
- POSTGRES_USER=${POSTGRES_USER}
- POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
- POSTGRES_DB=${POSTGRES_DB}
volume_mounts:
- mountPath: /var/lib/postgresql/data
name: postgres-data
deploy:
memory: 2Gi
cpu: 1.0
redis:
image: "redis:7-alpine"
deploy:
memory: 512Mi
cpu: 0.5
CI/CD Pipeline Integration
name: Deploy to Railway
on:
push:
branches: [main , develop ]
pull_request:
branches: [main ]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'npm'
- name: Install dependencies
run: npm ci
- name: Run tests
run: npm test
- name: Run E2E tests
run: npm run test:e2e
deploy:
needs: test
runs-on: ubuntu-latest
if: github.ref == 'refs/heads/main'
steps:
- uses: actions/checkout@v4
- name: Install Railway CLI
run: npm install -g @railway/cli
- name: Deploy to Railway
env:
RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}
run: |
railway login --token $RAILWAY_TOKEN
railway up --service frontend,backend,worker
Advanced Implementation (Level 3)
Advanced Scaling Strategies class RailwayScalingManager :
def __init__ (self ):
self .railway_client = RailwayClient()
self .metrics_analyzer = MetricsAnalyzer()
self .cost_optimizer = CostOptimizer()
async def implement_intelligent_scaling (self,
project_id: str ,
scaling_config: ScalingConfiguration ) -> ScalingImplementation:
"""Implement intelligent auto-scaling for Railway services."""
usage_analysis = await self .metrics_analyzer.analyze_usage_patterns(
project_id, timeframe="7d"
)
predictive_config = self ._configure_predictive_scaling(
usage_analysis,
scaling_config
)
cost_optimization = self .cost_optimizer.optimize_scaling_costs(
predictive_config,
scaling_config.budget_constraints
)
return ScalingImplementation(
scaling_rules=self ._create_scaling_rules(predictive_config),
monitoring_setup=self ._setup_scaling_monitoring(),
cost_controls=cost_optimization,
performance_alerts=self ._configure_performance_alerts()
)
Database Optimization Patterns
import { Pool } from 'pg' ;
const productionPool = new Pool ({
connectionString : process.env .DATABASE_URL ,
ssl : { rejectUnauthorized : false },
max : 20 ,
min : 5 ,
idleTimeoutMillis : 30000 ,
connectionTimeoutMillis : 2000 ,
statement_timeout : 10000 ,
retry : 3 ,
retryDelay : 1000 ,
});
export class DatabaseService {
private pool = productionPool;
async query<T>(text : string , params ?: any []): Promise <T[]> {
const start = Date .now ();
const client = await this .pool .connect ();
try {
const result = await client.query (text, params);
const duration = Date .now () - start;
if (duration > 1000 ) {
console .warn ('Slow query detected:' , {
query : text,
duration,
rowCount : result.rowCount
});
}
return result.rows ;
} finally {
client.release ();
}
}
async transaction<T>(callback : (client : any Promise <T>): Promise <T> {
const client = await this .pool .connect ();
try {
await client.query ('BEGIN' );
const result = await callback (client);
await client.query ('COMMIT' );
return result;
} catch (error) {
await client.query ('ROLLBACK' );
throw error;
} finally {
client.release ();
}
}
}
app.get ('/api/health' , async (req, res) => {
try {
await db.query ('SELECT 1' );
res.status (200 ).json ({
status : 'healthy' ,
timestamp : new Date ().toISOString (),
database : 'connected'
});
} catch (error) {
res.status (503 ).json ({
status : 'unhealthy' ,
timestamp : new Date ().toISOString (),
database : 'disconnected'
});
}
});
Environment Management class RailwayEnvironmentManager :
def __init__ (self ):
self .railway_client = RailwayClient()
self .config_manager = ConfigurationManager()
def setup_production_environment (self, project_id: str , config: EnvironmentConfig ) -> EnvironmentSetup:
"""Configure production environment with best practices."""
production_vars = {
'NODE_ENV' : 'production' ,
'LOG_LEVEL' : 'info' ,
'DATABASE_URL' : config.database_url,
'DATABASE_POOL_SIZE' : '20' ,
'DATABASE_TIMEOUT' : '10000' ,
'JWT_SECRET' : config.jwt_secret,
'ENCRYPTION_KEY' : config.encryption_key,
'CORS_ORIGIN' : config.frontend_url,
'REDIS_URL' : config.redis_url,
'EMAIL_SERVICE_API_KEY' : config.email_api_key,
'SENTRY_DSN' : config.sentry_dsn,
'LOGTAIL_SOURCE_TOKEN' : config.logtail_token
}
env_setup = self .railway_client.set_environment_variables(
project_id, production_vars
)
return EnvironmentSetup(
variables=production_vars,
security_config=self ._configure_security(),
monitoring_config=self ._configure_monitoring(),
backup_config=self ._configure_backups()
)
Reference & Integration (Level 4)
API Reference
Core Railway Operations
deploy_service(project_id, service_config) - Deploy servicecreate_database(project_id, db_type) - Provision databasescale_service(service_id, replicas, resources) - Scale servicerollback_deployment(service_id, deployment_id) - Rollback deploymentset_environment_variables(project_id, variables) - Set environment variables
Context7 Integration
get_latest_railway_documentation() - Official Railway docs via Context7analyze_container_optimization() - Container best practices via Context7optimize_deployment_strategy() - Deployment patterns via Context7
Best Practices (November 2025)
DO
Use separate environments for development, staging, and production
Implement comprehensive health checks for all services
Configure proper logging and monitoring for observability
Use connection pooling for database connections
Set up automated testing before deployments
Monitor costs and implement spending limits
Use volume mounts for persistent data storage
Implement proper error handling and retry logic
DON'T
Hardcode environment variables in application code
Skip health checks and monitoring setup
Use production database for development testing
Ignore scaling limits and cost controls
Deploy without proper testing
Forget to implement backup strategies
Overprovision resources without optimization
Skip security configuration for production
Works Well With
moai-baas-foundation (Enterprise BaaS architecture patterns)moai-domain-backend (Backend deployment patterns)moai-domain-devops (DevOps and CI/CD workflows)moai-essentials-perf (Performance optimization)moai-foundation-trust (Security and compliance)moai-baas-vercel-ext (Frontend deployment comparison)moai-baas-neon-ext (PostgreSQL database integration)moai-domain-database (Database optimization)
Changelog
v4.0.0 (2025-11-13): Complete Enterprise v4.0 rewrite with 40% content reduction, 4-layer Progressive Disclosure structure, Context7 integration, November 2025 Railway platform updates, and advanced deployment automationv2.0.0 (2025-11-11): Complete metadata structure, deployment patterns, CI/CD integrationv1.0.0 (2025-11-11): Initial Railway full-stack platform
End of Skill | Updated 2025-11-13
Security & Compliance
Container Security
Secure base images and vulnerability scanning
Runtime security monitoring and threat detection
Network isolation and firewall configuration
Secret management with encrypted environment variables
Compliance Management
GDPR compliance with data protection measures
SOC2 Type II security controls
Automated security scanning and patching
Comprehensive audit logging and monitoring
End of Enterprise Railway Full-Stack Platform Expert v4.0.0
