Deploy Config

Kuberns simplifies the deployment configuration process by leveraging AI to automatically detect and configure your application stack, including runtime versions, dependencies, and build settings.

This ensures a faster and more reliable deployment process.

This document explains how Kuberns handles deployment configuration, with options to customize settings directly through the Kuberns Dashboard for advanced use cases.

AI-Driven Deployment Configuration

Kuberns AI automatically analyzes your codebase upon deployment to configure the optimal settings for your application. This includes:

• Application Stack Detection: Identifies your framework and runtime (e.g., Python, Node.js) without requiring manual specification.
• Dependency Management: Installs necessary dependencies based on your project’s requirements.
• Build Optimization: Configures build scripts and environment settings to ensure consistency across development, staging, and production environments.
• Resource Allocation: Allocates compute resources based on your application’s needs, with predictive scaling to handle traffic spikes.

This automation minimizes errors, reduces setup time, and ensures your application is deployed with best practices, making the process seamless for users of all experience levels.

Runtime configuration

While Kuberns automatically selects the most compatible runtime version for your application, you can customize the runtime version using the Kuberns Dashboard if needed.

How it works?

• Default Behavior: Kuberns AI detects and selects the latest stable runtime version for your framework.
• Custom Configuration: You can specify a custom runtime version directly in the Deploy Config section of the Kuberns Dashboard.

Customizing the Runtime

1. Navigate to the Deploy Config section in the Kuberns Dashboard.
2. Locate the Runtime Configuration option.
3. Select your desired runtime version.
4. Save the changes and redeploy your application to apply the new runtime.

If no custom runtime is specified, Kuberns will continue to use the AI-selected default.

Pre-Build Configuration

Kuberns AI automatically handles pre-build tasks, such as installing dependencies and setting up the environment, based on your project’s structure. However, you can define custom pre-build commands using the Kuberns Dashboard for specific needs.

Importance of Pre-Build Tasks

Pre-build tasks ensure your environment is properly prepared before the build process begins, reducing the likelihood of failures and ensuring consistency across deployments.

Configuring Custom Pre-Build Tasks

1. Navigate to the Deploy Config section in the Kuberns Dashboard.
2. Locate the Pre-Build Scripts section.
3. Add the commands you want to execute before the build starts. For example:
   • Install additional dependencies: npm install --production
   • Run a custom script: npm run prebuild-script
   • Set a temporary environment variable: export BUILD_ENV=staging
4. Save the changes and redeploy your application. Kuberns will execute these commands before initiating the build.

If no custom pre-build commands are specified, Kuberns AI will handle post-build tasks automatically, ensuring your application starts correctly.

Post-Build Configuration

Kuberns automates post-build tasks, such as starting your application and optimizing resources, but you can define custom post-build commands using the Kuberns Dashboard if needed.

Importance of Post-Build Tasks

Post-build tasks finalize your deployment by performing actions like running database migrations, cleaning up temporary files, or starting background workers, ensuring your application is production-ready.

Configuring Custom Post-Build Tasks

1. Navigate to the Deploy Config section in the Kuberns Dashboard.
2. Locate the Post-Build Scripts section.
3. Add the commands you want to execute after the build completes. For example:
   • Run database migrations: npm run migrate
   • Clean up temporary files: rm -rf temp/
   • Start background workers: npm run start-workers
4. Save the changes and redeploy your application. Kuberns will execute these commands after the build process.

If no custom post-build commands are specified, Kuberns AI will handle post-build tasks automatically, ensuring your application starts correctly.

Best Practices for Deploy Config

• Rely on AI Defaults: For most applications, Kuberns’ AI-driven configuration is sufficient, minimizing manual setup and potential errors.
• Use Manual Overrides Sparingly: Only specify custom runtime versions or scripts when necessary, as AI defaults are optimized for stability and performance.
• Test Configurations Locally: Before deploying with custom pre-build or post-build scripts, test them in a local environment to avoid deployment failures.
• Monitor Logs: Use the Logs section in the Kuberns Dashboard to verify that your build and deployment processes complete successfully.