Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-baas-railway-extLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... 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).
Métiers associés SOC
Basé sur la classification professionnelle 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
