Tilt for Live Development in Java

Introduction

Tilt is a development environment tool that automates building, deploying, and updating microservices. For Java developers, Tilt enables rapid iteration by automatically rebuilding and redeploying applications when code changes, significantly reducing the feedback loop during development.

Architecture Overview

1. Tilt Development Workflow

Java Source Changes → Tilt Detects → Rebuild Container → Redeploy to K8s → Live Update ↓ ↓ ↓ ↓ ↓ Local IDE File Watcher Docker Build kubectl apply Hot Reload ↓ ↓ ↓ ↓ ↓ Code Changes Trigger Build New Image Pod Restart Spring DevTools

Setup and Dependencies

1. Project Structure

java-microservice/ ├── src/ │ └── main/ │ └── java/ │ └── com/example/ │ └── app/ ├── src/test/java/ ├── tilt_modules/ ├── k8s/ │ ├── deployment.yaml │ └── service.yaml ├── Dockerfile ├── Tiltfile ├── pom.xml └── .tiltignore

2. Maven Dependencies for Live Development

<properties> <spring-boot.version>3.1.0</spring-boot.version> <spring-boot-devtools.version>3.1.0</spring-boot-devtools.version> <jib-maven-plugin.version>3.3.2</jib-maven-plugin.version> </properties> <dependencies> <!-- Spring Boot with DevTools for hot reload --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${spring-boot.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <version>${spring-boot-devtools.version}</version> <optional>true</optional> <scope>runtime</scope> </dependency> <!-- Actuator for health checks --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> <version>${spring-boot.version}</version> </dependency> <!-- LiveReload support --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> <version>${spring-boot.version}</version> </dependency> </dependencies> <build> <plugins> <!-- Spring Boot Maven Plugin --> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <version>${spring-boot.version}</version> <configuration> <excludeDevtools>false</excludeDevtools> <fork>true</fork> </configuration> </plugin> <!-- Jib for container building --> <plugin> <groupId>com.google.cloud.tools</groupId> <artifactId>jib-maven-plugin</artifactId> <version>${jib-maven-plugin.version}</version> </plugin> </plugins> </build>

Tilt Configuration

1. Basic Tiltfile

# Tiltfile # Enable experimental features enable_feature('wait_for_ports') # Set Kubernetes context k8s_context('docker-desktop') # or 'minikube', 'kind' # Load common functions load('ext://restart_process', 'docker_build_with_restart') # Define global settings allow_k8s_contexts('docker-desktop', 'minikube', 'kind') # Configure live update settings live_update_base_image = 'eclipse-temurin:17-jre' # Java application configuration java_app_name = 'user-service' java_app_path = './user-service' # Docker build configuration docker_build( ref = java_app_name, context = java_app_path, dockerfile = 'Dockerfile', live_update = [ # Sync Java source files sync( local_path = java_app_path + '/src/main/java', remote_path = '/app/src/main/java' ), # Sync resources sync( local_path = java_app_path + '/src/main/resources', remote_path = '/app/src/main/resources' ), # Run Maven compilation in container run('mvn compile -DskipTests', trigger = [ java_app_path + '/src/main/java/**/*.java', java_app_path + '/pom.xml' ]), # Restart Spring Boot application restart_container() ] ) # Kubernetes deployment k8s_yaml('k8s/deployment.yaml') k8s_yaml('k8s/service.yaml') # Resource configuration k8s_resource( java_app_name, port_forwards = [8080], resource_deps = ['docker_build'], extra_pod_selectors = [{'app': java_app_name}] ) # Local development resources local_resource( name = 'run-tests', cmd = 'mvn test', trigger = [ java_app_path + '/src/test/java/**/*.java', java_app_path + '/src/main/java/**/*.java' ], ignore = ['target/'], deps = [java_app_path] ) # Database setup (if needed) local_resource( name = 'db-migrations', cmd = 'mvn flyway:migrate -Dflyway.url=jdbc:postgresql://localhost:5432/devdb', trigger = [java_app_path + '/src/main/resources/db/migration/**/*.sql'], deps = [java_app_path] )

2. Advanced Multi-Service Tiltfile

# Tiltfile for microservices architecture # Project configuration project_name = 'java-microservices' team_name = 'development-team' # Enable extensions enable_feature('wait_for_ports') # Common configuration common_deps = ['./lib/**/*.jar', './pom.xml'] # Define microservices microservices = [ { 'name': 'user-service', 'path': './services/user-service', 'port': 8080, 'context': './services/user-service', 'deps': common_deps + ['./services/user-service/src/**/*'] }, { 'name': 'order-service', 'path': './services/order-service', 'port': 8081, 'context': './services/order-service', 'deps': common_deps + ['./services/order-service/src/**/*'] }, { 'name': 'payment-service', 'path': './services/payment-service', 'port': 8082, 'context': './services/payment-service', 'deps': common_deps + ['./services/payment-service/src/**/*'] } ] # Database service docker_compose('./docker-compose.db.yml') # Build and deploy each microservice for service in microservices: # Docker build with live updates docker_build( ref = service['name'], context = service['context'], dockerfile = 'Dockerfile.dev', live_update = [ # Sync source code sync( local_path = service['path'] + '/src/main/java', remote_path = '/app/src/main/java' ), sync( local_path = service['path'] + '/src/main/resources', remote_path = '/app/src/main/resources' ), # Trigger compilation on Java file changes run( cmd = 'mvn compile -DskipTests -q', trigger = [ service['path'] + '/src/main/java/**/*.java', service['path'] + '/pom.xml' ] ), # Restart Spring Boot application restart_container() ], only = [ service['path'] + '/src/**/*', service['path'] + '/pom.xml' ] ) # Kubernetes deployment k8s_yaml(service['path'] + '/k8s/deployment.yaml') k8s_yaml(service['path'] + '/k8s/service.yaml') # Resource configuration k8s_resource( service['name'], port_forwards = [service['port']], resource_deps = ['docker_build'], extra_pod_selectors = [{'app': service['name']}], objects = ['deployment/' + service['name']] ) # Common dependencies local resource local_resource( name = 'build-common', cmd = 'mvn install -DskipTests', trigger = ['./lib/**/*.java', './pom.xml'], deps = ['./lib', './pom.xml'] ) # API Gateway docker_build( ref = 'api-gateway', context = './gateway', dockerfile = 'Dockerfile.dev', live_update = [ sync('./gateway/src', '/app/src'), run('npm run build', trigger = ['./gateway/src/**/*.js']), restart_container() ] ) k8s_yaml('./gateway/k8s/gateway.yaml') k8s_resource('api-gateway', port_forwards=[80]) # Test runner local_resource( name = 'integration-tests', cmd = './scripts/run-integration-tests.sh', trigger = [ './services/**/src/**/*.java', './integration-tests/**/*.java' ], allow_parallel = False )

Docker Configuration for Live Development

1. Development Dockerfile

# Dockerfile.dev FROM eclipse-temurin:17-jdk as builder # Install Maven RUN apt-get update && apt-get install -y maven WORKDIR /app # Copy pom.xml first for better layer caching COPY pom.xml . COPY src ./src # Download dependencies (cached unless pom.xml changes) RUN mvn dependency:go-offline -B # Development stage FROM eclipse-temurin:17-jdk WORKDIR /app # Install Maven and dev tools RUN apt-get update && apt-get install -y \ maven \ curl \ && rm -rf /var/lib/apt/lists/* # Copy from builder stage COPY --from=builder /root/.m2 /root/.m2 COPY --from=builder /app /app # Create non-root user RUN groupadd -r spring && useradd -r -g spring spring USER spring # Expose debug port for remote debugging EXPOSE 8080 5005 # Health check HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ CMD curl -f http://localhost:8080/actuator/health || exit 1 # Development entry point with debug enabled ENTRYPOINT ["mvn", "spring-boot:run", \ "-Dspring-boot.run.jvmArguments=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005", \ "-Dspring-boot.run.fork=false"]

2. Multi-Stage Dockerfile for Production

# Dockerfile (production) # Build stage FROM eclipse-temurin:17-jdk as builder WORKDIR /app COPY pom.xml . RUN mvn dependency:go-offline -B COPY src ./src RUN mvn package -DskipTests # Runtime stage FROM eclipse-temurin:17-jre WORKDIR /app RUN groupadd -r spring && useradd -r -g spring spring USER spring COPY --from=builder /app/target/*.jar app.jar EXPOSE 8080 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ CMD curl -f http://localhost:8080/actuator/health || exit 1 ENTRYPOINT ["java", "-jar", "/app.jar"]

Kubernetes Manifests for Development

1. Development Deployment

# k8s/deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: user-service labels: app: user-service environment: development spec: replicas: 1 selector: matchLabels: app: user-service template: metadata: labels: app: user-service environment: development annotations: # Tilt-specific annotations tilt.dev/update-id: "user-service" # Live update annotations tilt.dev/live-update: "true" spec: containers: - name: user-service image: user-service:latest ports: - containerPort: 8080 - containerPort: 5005 # Debug port env: - name: SPRING_PROFILES_ACTIVE value: "development" - name: JAVA_TOOL_OPTIONS value: "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005" - name: SPRING_DEVTOOLS_RESTART_ENABLED value: "true" - name: SPRING_DEVTOOLS_LIVELOAD_ENABLED value: "true" resources: requests: memory: "512Mi" cpu: "200m" limits: memory: "1Gi" cpu: "500m" livenessProbe: httpGet: path: /actuator/health/liveness port: 8080 initialDelaySeconds: 60 periodSeconds: 10 readinessProbe: httpGet: path: /actuator/health/readiness port: 8080 initialDelaySeconds: 30 periodSeconds: 5 # Development-specific settings stdin: true tty: true volumeMounts: - name: dev-config mountPath: /app/config - name: maven-cache mountPath: /root/.m2 volumes: - name: dev-config configMap: name: user-service-dev-config - name: maven-cache emptyDir: {} # Tolerations for development nodes tolerations: - key: "environment" operator: "Equal" value: "development" effect: "NoSchedule" --- # Service apiVersion: v1 kind: Service metadata: name: user-service labels: app: user-service spec: selector: app: user-service ports: - name: http port: 80 targetPort: 8080 - name: debug port: 5005 targetPort: 5005 type: ClusterIP

2. Development ConfigMap

# k8s/configmap.yaml apiVersion: v1 kind: ConfigMap metadata: name: user-service-dev-config data: application.yml: | spring: application: name: user-service devtools: restart: enabled: true livereload: enabled: true datasource: url: jdbc:postgresql://postgres:5432/devdb username: developer password: developer jpa: hibernate: ddl-auto: validate show-sql: true properties: hibernate: format_sql: true logging: level: com.example.userservice: DEBUG org.hibernate.SQL: DEBUG org.hibernate.type.descriptor.sql.BasicBinder: TRACE management: endpoints: web: exposure: include: health,info,metrics,loggers endpoint: health: show-details: always loggers: enabled: true

Java Application Configuration for Live Development

1. Spring Boot DevTools Configuration

// src/main/resources/application-development.yml spring: devtools: restart: enabled: true # Exclude static resources from triggering restart exclude: static/**,public/**,templates/** # Additional paths to watch additional-paths: src/main/java,src/main/resources livereload: enabled: true port: 35729 thymeleaf: cache: false freemarker: cache: false groovy: template: cache: false mustache: cache: false # Remote debugging configuration server: port: 8080 # Development-specific logging logging: level: org.springframework.web: DEBUG com.example: DEBUG org.hibernate: DEBUG

2. Development-Specific Beans

@Configuration @Profile("development") @Slf4j public class DevelopmentConfig { @Bean public CommandLineRunner developmentDataLoader(UserRepository userRepository) { return args -> { log.info("Loading development data..."); // Create test users User testUser = User.builder() .email("[email protected]") .firstName("Development") .lastName("User") .build(); userRepository.save(testUser); log.info("Development data loaded successfully"); }; } @Bean @ConditionalOnMissingBean public RestTemplate restTemplate() { // Development RestTemplate with longer timeouts return new RestTemplateBuilder() .setConnectTimeout(Duration.ofSeconds(30)) .setReadTimeout(Duration.ofSeconds(30)) .build(); } @Bean public FilterRegistrationBean<RequestLoggingFilter> loggingFilter() { FilterRegistrationBean<RequestLoggingFilter> registrationBean = new FilterRegistrationBean<>(); RequestLoggingFilter loggingFilter = new RequestLoggingFilter(); loggingFilter.setIncludeClientInfo(true); loggingFilter.setIncludeQueryString(true); loggingFilter.setIncludePayload(true); loggingFilter.setMaxPayloadLength(10000); registrationBean.setFilter(loggingFilter); registrationBean.addUrlPatterns("/*"); return registrationBean; } }

3. Live Development Controller

@RestController @RequestMapping("/dev") @Profile("development") @Slf4j public class DevelopmentController { private final ApplicationContext applicationContext; private final UserRepository userRepository; public DevelopmentController(ApplicationContext applicationContext, UserRepository userRepository) { this.applicationContext = applicationContext; this.userRepository = userRepository; } @PostMapping("/reload") public ResponseEntity<String> triggerReload() { log.info("Manual reload triggered via development endpoint"); // This will trigger Spring Boot DevTools restart return ResponseEntity.ok("Reload triggered"); } @GetMapping("/info") public ResponseEntity<DevelopmentInfo> getDevelopmentInfo() { DevelopmentInfo info = DevelopmentInfo.builder() .activeProfiles(applicationContext.getEnvironment().getActiveProfiles()) .startupTime(ManagementFactory.getRuntimeMXBean().getStartTime()) .uptime(ManagementFactory.getRuntimeMXBean().getUptime()) .userCount(userRepository.count()) .build(); return ResponseEntity.ok(info); } @PostMapping("/reset-data") public ResponseEntity<String> resetTestData() { log.info("Resetting test data..."); userRepository.deleteAll(); // Reload initial test data User testUser = User.builder() .email("[email protected]") .firstName("Test") .lastName("User") .build(); userRepository.save(testUser); return ResponseEntity.ok("Test data reset successfully"); } @GetMapping("/config") public ResponseEntity<Map<String, Object>> getConfiguration() { Map<String, Object> config = new HashMap<>(); // Expose relevant configuration properties config.put("spring.datasource.url", applicationContext.getEnvironment().getProperty("spring.datasource.url")); config.put("server.port", applicationContext.getEnvironment().getProperty("server.port")); config.put("spring.jpa.show-sql", applicationContext.getEnvironment().getProperty("spring.jpa.show-sql")); return ResponseEntity.ok(config); } @Data @Builder public static class DevelopmentInfo { private String[] activeProfiles; private long startupTime; private long uptime; private long userCount; } }

Advanced Tilt Features

1. Custom Live Update Strategies

# tilt_modules/java_live_update/Tiltfile def java_live_update(name, src_path, resource_paths=None): """Custom live update function for Java applications""" if resource_paths is None: resource_paths = [] # Base live update steps live_update_steps = [ # Sync Java source files sync( local_path = src_path + '/src/main/java', remote_path = '/app/src/main/java' ), # Sync resources sync( local_path = src_path + '/src/main/resources', remote_path = '/app/src/main/resources' ), ] # Add additional resource paths for resource_path in resource_paths: live_update_steps.append( sync( local_path = src_path + '/' + resource_path, remote_path = '/app/' + resource_path ) ) # Compilation step live_update_steps.append( run( cmd = 'mvn compile -DskipTests -q', trigger = [ src_path + '/src/main/java/**/*.java', src_path + '/pom.xml' ] ) ) # Restart application live_update_steps.append(restart_container()) return live_update_steps def watch_test_files(name, test_path): """Watch test files and run tests on changes""" local_resource( name = name + '-tests', cmd = 'mvn test -Dtest="**/*Test"', trigger = [ test_path + '/src/test/java/**/*.java', test_path + '/src/main/java/**/*.java' ], ignore = ['target/'], deps = [test_path] )

2. Database Integration

# tilt_modules/database/Tiltfile def setup_development_database(): """Setup development database with test data""" # PostgreSQL development database docker_compose('docker-compose.db.yml') # Database migrations local_resource( name = 'db-migrations', cmd = 'mvn flyway:migrate -Dflyway.url=jdbc:postgresql://localhost:5432/devdb', trigger = [ './src/main/resources/db/migration/**/*.sql' ], deps = ['./src/main/resources/db/migration'] ) # Test data loader local_resource( name = 'test-data', cmd = 'mvn spring-boot:run -Dspring-boot.run.arguments=--spring.profiles.active=testdata', trigger = [ './src/main/resources/data.sql' ], deps = ['./src/main/resources/data.sql'] )

Local Development Scripts

1. Development Bootstrap Script

#!/bin/bash # scripts/dev-bootstrap.sh set -e echo "🚀 Bootstrapping Java development environment..." # Check prerequisites command -v docker >/dev/null 2>&1 || { echo "Docker is required but not installed."; exit 1; } command -v tilt >/dev/null 2>&1 || { echo "Tilt is required but not installed."; exit 1; } command -v mvn >/dev/null 2>&1 || { echo "Maven is required but not installed."; exit 1; } # Build common dependencies echo "📦 Building common dependencies..." mvn clean install -DskipTests # Start database echo "🐘 Starting development database..." docker-compose -f docker-compose.db.yml up -d # Wait for database to be ready echo "⏳ Waiting for database to be ready..." until docker exec java-dev-db pg_isready -U developer; do sleep 1 done # Run database migrations echo "🔄 Running database migrations..." mvn flyway:migrate -Dflyway.url=jdbc:postgresql://localhost:5432/devdb # Start Tilt echo "🎯 Starting Tilt development environment..." tilt up echo "✅ Development environment is ready!" echo "📊 Tilt UI: http://localhost:10350" echo "🔧 User Service: http://localhost:8080"

2. Docker Compose for Database

# docker-compose.db.yml version: '3.8' services: postgres: image: postgres:15 container_name: java-dev-db environment: POSTGRES_DB: devdb POSTGRES_USER: developer POSTGRES_PASSWORD: developer ports: - "5432:5432" volumes: - postgres_data:/var/lib/postgresql/data - ./init-db:/docker-entrypoint-initdb.d networks: - java-dev-network redis: image: redis:7-alpine container_name: java-dev-redis ports: - "6379:6379" networks: - java-dev-network volumes: postgres_data: networks: java-dev-network: driver: bridge

Monitoring and Debugging

1. Tilt Resource Configuration

# Tiltfile - Monitoring setup # Add resource utilization monitoring k8s_resource( 'user-service', port_forwards = [8080], resource_deps = ['docker_build'], extra_pod_selectors = [{'app': 'user-service'}], # Resource limits for development object_selector = { 'deployment': 'user-service' } ) # Development metrics and logging local_resource( name = 'monitor-logs', cmd = 'kubectl logs -f deployment/user-service', serve_cmd = 'kubectl logs -f deployment/user-service --tail=100', trigger_mode = TRIGGER_MODE_MANUAL ) local_resource( name = 'monitor-metrics', cmd = 'kubectl port-forward deployment/user-service 9090:8080 && curl http://localhost:9090/actuator/metrics', serve_cmd = 'kubectl port-forward deployment/user-service 9090:8080', trigger_mode = TRIGGER_MODE_MANUAL ) # Debugging helpers local_resource( name = 'debug-shell', cmd = 'kubectl exec -it deployment/user-service -- /bin/bash', trigger_mode = TRIGGER_MODE_MANUAL ) local_resource( name = 'describe-pod', cmd = 'kubectl describe pod -l app=user-service', trigger_mode = TRIGGER_MODE_MANUAL )

2. Health Check Endpoints

@RestController @RequestMapping("/actuator") @Slf4j public class DevelopmentHealthController { private final DataSource dataSource; private final RedisConnectionFactory redisConnectionFactory; public DevelopmentHealthController(DataSource dataSource, RedisConnectionFactory redisConnectionFactory) { this.dataSource = dataSource; this.redisConnectionFactory = redisConnectionFactory; } @GetMapping("/health/development") public ResponseEntity<DevelopmentHealth> developmentHealth() { DevelopmentHealth health = DevelopmentHealth.builder() .status("UP") .timestamp(Instant.now()) .build(); try { // Check database connectivity try (Connection connection = dataSource.getConnection()) { health.setDatabase("UP"); } } catch (Exception e) { health.setDatabase("DOWN"); health.setStatus("DEGRADED"); } // Check Redis connectivity try { redisConnectionFactory.getConnection().close(); health.setRedis("UP"); } catch (Exception e) { health.setRedis("DOWN"); health.setStatus("DEGRADED"); } return ResponseEntity.ok(health); } @Data @Builder public static class DevelopmentHealth { private String status; private Instant timestamp; private String database; private String redis; private Map<String, Object> details; public DevelopmentHealth() { this.details = new HashMap<>(); } } }

Team Development Configuration

1. Team-Specific Tilt Configuration

# Tiltfile.team # Team-specific development configuration team_name = os.getenv("DEV_TEAM", "default") # Team-specific resource settings if team_name == "backend": # Backend team needs all services microservices = ["user-service", "order-service", "payment-service", "inventory-service"] elif team_name == "frontend": # Frontend team only needs API gateway and user service microservices = ["user-service", "api-gateway"] else: # Default: core services only microservices = ["user-service", "order-service"] # Team-specific port allocations port_allocations = { "backend": { "user-service": 8080, "order-service": 8081, "payment-service": 8082, "inventory-service": 8083 }, "frontend": { "user-service": 8080, "api-gateway": 8081 } } # Apply team configuration current_ports = port_allocations.get(team_name, port_allocations["default"]) for service in microservices: port = current_ports.get(service, 8080) k8s_resource( service, port_forwards = [port], resource_deps = ['docker_build'], extra_pod_selectors = [{'app': service}] )

2. Development Environment Validation

@Component @Slf4j public class DevelopmentEnvironmentValidator { private final ApplicationContext applicationContext; private final Environment environment; public DevelopmentEnvironmentValidator(ApplicationContext applicationContext, Environment environment) { this.applicationContext = applicationContext; this.environment = environment; } @EventListener public void onApplicationEvent(ApplicationReadyEvent event) { if (Arrays.stream(environment.getActiveProfiles()) .anyMatch(profile -> profile.equals("development"))) { validateDevelopmentEnvironment(); } } private void validateDevelopmentEnvironment() { log.info("🔍 Validating development environment..."); List<String> warnings = new ArrayList<>(); List<String> errors = new ArrayList<>(); // Check database connectivity try { DataSource dataSource = applicationContext.getBean(DataSource.class); try (Connection conn = dataSource.getConnection()) { if (!conn.isValid(5)) { errors.add("Database connection is not valid"); } } } catch (Exception e) { errors.add("Cannot connect to database: " + e.getMessage()); } // Check Redis connectivity try { RedisConnectionFactory redisFactory = applicationContext.getBean(RedisConnectionFactory.class); redisFactory.getConnection().close(); } catch (Exception e) { warnings.add("Redis is not available: " + e.getMessage()); } // Log results if (!errors.isEmpty()) { log.error("❌ Development environment validation failed:"); errors.forEach(error -> log.error(" - {}", error)); } if (!warnings.isEmpty()) { log.warn("⚠️ Development environment warnings:"); warnings.forEach(warning -> log.warn(" - {}", warning)); } if (errors.isEmpty() && warnings.isEmpty()) { log.info("✅ Development environment validation passed"); } } }

Performance Optimization

1. Optimized Tilt Configuration

# Tiltfile.optimized # Performance optimizations for large Java projects enable_feature('disable_snapshots') # Configure build parallelism settings = { 'max_parallel_builds': 3, 'enable_snapshots': False, 'k8s_connection_timeout': '30s', 'docker_build_max_parallel': 2 } # Cache configuration cache_path = os.getenv("TILT_CACHE_PATH", "/tmp/tilt-cache") # Optimized Docker builds for Java def optimized_java_build(name, path): docker_build( ref = name, context = path, dockerfile = 'Dockerfile.dev', cache_from = [name + ':latest'], live_update = [ sync(path + '/src/main/java', '/app/src/main/java'), sync(path + '/src/main/resources', '/app/src/main/resources'), run('mvn compile -DskipTests -T 1C -q', trigger = [path + '/src/main/java/**/*.java', path + '/pom.xml']), restart_container() ], only = [ path + '/src/main/java/**/*.java', path + '/src/main/resources/**/*', path + '/pom.xml' ], ignore = [ path + '/target/**/*', path + '/**/*.class' ] )

Conclusion

Tilt provides a powerful live development environment for Java applications with:

Rapid Iteration - Automatic rebuild and redeploy on code changes
Hot Reload - Spring Boot DevTools integration for instant updates
Multi-Service Management - Coordinated development across microservices
Local Kubernetes - Realistic development environment matching production
Team Collaboration - Consistent development setup across teams

By implementing Tilt with the configurations shown above, Java development teams can achieve:

Faster feedback loops - See changes in seconds instead of minutes
Consistent environments - Everyone works with the same setup
Production-like development - Develop against real dependencies
Easy onboarding - New developers can start contributing quickly

The combination of Tilt, Spring Boot DevTools, and proper Docker/Kubernetes configuration creates an optimal development experience for Java microservices.