28 Automatisierung von Builds und Deployments

// CI-optimized Build Configuration
tasks.register("ciBuild") {
    description = "Complete build for CI pipeline"
    group = "ci"
    
    dependsOn("clean", "assemble", "check", "jacocoTestReport")
    
    doFirst {
        // CI-spezifische Konfiguration
        project.extra["ci.build"] = true
        project.extra["build.number"] = System.getenv("BUILD_NUMBER") ?: "LOCAL"
        project.extra["build.timestamp"] = Instant.now().toString()
        
        logger.lifecycle("Starting CI Build #${project.extra["build.number"]}")
    }
    
    doLast {
        // Build-Metadaten für Pipeline
        val metadata = file("${buildDir}/ci-metadata.json")
        metadata.writeText(groovy.json.JsonOutput.toJson(mapOf(
            "project" to project.name,
            "version" to project.version,
            "buildNumber" to project.extra["build.number"],
            "timestamp" to project.extra["build.timestamp"],
            "commitHash" to executeGitCommand("rev-parse HEAD"),
            "branch" to executeGitCommand("rev-parse --abbrev-ref HEAD"),
            "artifacts" to collectBuildArtifacts()
        )))
    }
}

// Pipeline-Stage-Tasks
tasks.register("ciCompile") {
    description = "Compilation stage for CI"
    dependsOn("compileJava", "compileTestJava", "processResources")
}

tasks.register("ciTest") {
    description = "Test execution stage for CI"
    dependsOn("test", "integrationTest")
    
    // Parallele Test-Execution für CI
    tasks.withType<Test>().configureEach {
        if (project.hasProperty("ci.build")) {
            maxParallelForks = Runtime.getRuntime().availableProcessors()
            failFast = false  // Alle Tests ausführen für vollständigen Report
        }
    }
}

tasks.register("ciPackage") {
    description = "Package artifacts for deployment"
    dependsOn("bootJar", "distZip")
    
    doLast {
        // Artifact Signing für Release Builds
        if (project.version.toString().matches(Regex("\\d+\\.\\d+\\.\\d+"))) {
            signArtifacts()
        }
    }
}

// Deployment Configuration
val deploymentEnvironments = mapOf(
    "dev" to DeploymentEnvironment(
        url = "https://dev.deploy.company.com",
        region = "eu-central-1",
        instances = 2,
        healthCheckPath = "/actuator/health",
        rolloutStrategy = "rolling"
    ),
    "staging" to DeploymentEnvironment(
        url = "https://staging.deploy.company.com",
        region = "eu-central-1",
        instances = 4,
        healthCheckPath = "/actuator/health",
        rolloutStrategy = "blue-green"
    ),
    "production" to DeploymentEnvironment(
        url = "https://prod.deploy.company.com",
        region = "eu-west-1",
        instances = 10,
        healthCheckPath = "/actuator/health",
        rolloutStrategy = "canary"
    )
)

// Generic Deployment Task
open class DeployTask : DefaultTask() {
    @Input
    val environment = project.objects.property<String>()
    
    @InputFile
    val artifact = project.objects.fileProperty()
    
    @Input
    val version = project.objects.property<String>()
    
    @TaskAction
    fun deploy() {
        val env = deploymentEnvironments[environment.get()] 
            ?: error("Unknown environment: ${environment.get()}")
        
        logger.lifecycle("Deploying ${artifact.get().asFile.name} to ${environment.get()}")
        
        // Pre-deployment validation
        validateArtifact(artifact.get().asFile)
        validateEnvironment(env)
        
        // Deployment execution
        when (env.rolloutStrategy) {
            "rolling" -> performRollingDeployment(env)
            "blue-green" -> performBlueGreenDeployment(env)
            "canary" -> performCanaryDeployment(env)
            else -> error("Unknown rollout strategy: ${env.rolloutStrategy}")
        }
        
        // Post-deployment verification
        waitForHealthCheck(env)
        runSmokeTests(env)
        
        logger.lifecycle("Deployment to ${environment.get()} completed successfully")
    }
    
    private fun performRollingDeployment(env: DeploymentEnvironment) {
        val batchSize = maxOf(1, env.instances / 3)
        
        for (batch in 0 until env.instances step batchSize) {
            val instances = (batch until minOf(batch + batchSize, env.instances))
            
            logger.lifecycle("Deploying to instances $instances")
            
            instances.forEach { instance ->
                deployToInstance(env, instance)
                Thread.sleep(5000) // Wait between instances
            }
            
            verifyBatch(env, instances)
        }
    }
}

// Environment-specific deployment tasks
deploymentEnvironments.keys.forEach { env ->
    tasks.register<DeployTask>("deployTo${env.capitalize()}") {
        description = "Deploy application to $env environment"
        group = "deployment"
        
        environment.set(env)
        artifact.set(tasks.named<Jar>("bootJar").flatMap { it.archiveFile })
        version.set(project.version.toString())
        
        // Environment-specific dependencies
        if (env != "dev") {
            dependsOn("check", "qualityGate")
        }
    }
}

# .github/workflows/ci-cd.yml
name: CI/CD Pipeline
on:
  push:
    branches: [main, develop]
  pull_request:

jobs:
  compile:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'
      - run: ./gradlew ciCompile
      - uses: actions/upload-artifact@v3
        with:
          name: compiled-classes
          path: build/classes

  test:
    needs: compile
    runs-on: ubuntu-latest
    strategy:
      matrix:
        test-suite: [unit, integration, contract]
    steps:
      - uses: actions/checkout@v3
      - uses: actions/download-artifact@v3
        with:
          name: compiled-classes
          path: build/classes
      - run: ./gradlew test${{ matrix.test-suite }}
      
  deploy:
    needs: test
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v3
      - run: ./gradlew deployToProduction

// Pipeline-Support-Tasks
tasks.register("pipelineInfo") {
    description = "Export pipeline information"
    
    doLast {
        val pipelineFile = file("${buildDir}/pipeline.json")
        pipelineFile.writeText(groovy.json.JsonOutput.toJson(mapOf(
            "stages" to listOf("compile", "test", "package", "deploy"),
            "tasks" to tasks.names.filter { it.startsWith("ci") || it.startsWith("deploy") },
            "artifacts" to listOf(
                "build/libs/${project.name}-${project.version}.jar",
                "build/distributions/${project.name}-${project.version}.zip"
            ),
            "testSuites" to listOf("unit", "integration", "contract", "performance"),
            "deploymentEnvironments" to deploymentEnvironments.keys
        )))
    }
}

// Stage-Gates zwischen Pipeline-Phasen
tasks.register("stageGate") {
    description = "Verify stage completion criteria"
    
    val stage = project.findProperty("stage") as String? ?: "compile"
    
    doLast {
        when (stage) {
            "compile" -> {
                require(file("build/classes/java/main").exists()) {
                    "Compilation artifacts missing"
                }
            }
            "test" -> {
                val testReport = file("build/reports/tests/test/index.html")
                require(testReport.exists()) { "Test reports missing" }
                
                val failures = parseTestFailures()
                require(failures == 0) { "$failures tests failed" }
            }
            "package" -> {
                val artifact = file("build/libs/${project.name}-${project.version}.jar")
                require(artifact.exists()) { "Package artifact missing" }
                require(artifact.length() > 0) { "Package artifact empty" }
            }
        }
        
        logger.lifecycle("Stage gate '$stage' passed")
    }
}

// Version Management
version = ComputedVersion(
    major = project.findProperty("version.major") as String? ?: "1",
    minor = project.findProperty("version.minor") as String? ?: "0",
    patch = project.findProperty("version.patch") as String? ?: "0",
    qualifier = determineVersionQualifier()
)

fun determineVersionQualifier(): String {
    val branch = executeGitCommand("rev-parse --abbrev-ref HEAD")
    val buildNumber = System.getenv("BUILD_NUMBER") ?: "LOCAL"
    
    return when {
        branch == "main" -> ""  // Release version
        branch == "develop" -> "-SNAPSHOT"
        branch.startsWith("feature/") -> "-${branch.substringAfter("feature/")}-SNAPSHOT"
        branch.startsWith("release/") -> "-RC${buildNumber}"
        else -> "-${branch}-SNAPSHOT"
    }
}

// Artifact Publishing
publishing {
    publications {
        create<MavenPublication>("maven") {
            from(components["java"])
            
            // Version-specific artifact configuration
            artifact(tasks.register<Jar>("sourcesJar") {
                from(sourceSets.main.get().allJava)
                archiveClassifier.set("sources")
            })
            
            if (!version.toString().contains("SNAPSHOT")) {
                artifact(tasks.register<Jar>("javadocJar") {
                    from(tasks.javadoc)
                    archiveClassifier.set("javadoc")
                })
            }
            
            // POM customization
            pom {
                name.set(project.name)
                description.set("${project.name} v${project.version}")
                url.set("https://github.com/company/${project.name}")
                
                scm {
                    connection.set("scm:git:git://github.com/company/${project.name}.git")
                    developerConnection.set("scm:git:ssh://github.com/company/${project.name}.git")
                    url.set("https://github.com/company/${project.name}")
                    tag.set(if (version.toString().contains("SNAPSHOT")) "HEAD" else "v${version}")
                }
            }
        }
    }
    
    repositories {
        maven {
            val releasesRepoUrl = uri("https://nexus.company.com/repository/maven-releases/")
            val snapshotsRepoUrl = uri("https://nexus.company.com/repository/maven-snapshots/")
            url = if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl
            
            credentials {
                username = System.getenv("NEXUS_USERNAME")
                password = System.getenv("NEXUS_PASSWORD")
            }
        }
    }
}

// Artifact Promotion
tasks.register("promoteArtifact") {
    description = "Promote artifact from staging to release"
    
    doLast {
        val stagingRepo = "https://nexus.company.com/repository/maven-staging/"
        val releaseRepo = "https://nexus.company.com/repository/maven-releases/"
        
        val artifact = "${project.group}:${project.name}:${project.version}"
        
        // Verify artifact in staging
        verifyArtifactExists(stagingRepo, artifact)
        
        // Run promotion tests
        runPromotionTests(artifact)
        
        // Copy to release repository
        copyArtifact(stagingRepo, releaseRepo, artifact)
        
        // Tag release in Git
        executeGitCommand("tag -a v${project.version} -m 'Release version ${project.version}'")
        executeGitCommand("push origin v${project.version}")
        
        logger.lifecycle("Artifact $artifact promoted to release")
    }
}

// Canary Deployment Implementation
tasks.register("deployCanary") {
    description = "Perform canary deployment with gradual rollout"
    
    doLast {
        val stages = listOf(
            CanaryStage(percentage = 5, duration = Duration.ofMinutes(10)),
            CanaryStage(percentage = 25, duration = Duration.ofMinutes(20)),
            CanaryStage(percentage = 50, duration = Duration.ofMinutes(30)),
            CanaryStage(percentage = 100, duration = null)
        )
        
        val metrics = MetricsCollector()
        
        stages.forEach { stage ->
            logger.lifecycle("Canary stage: ${stage.percentage}% traffic")
            
            // Update load balancer configuration
            updateTrafficDistribution(stage.percentage)
            
            // Deploy to canary instances
            deployToCanaryInstances(calculateInstanceCount(stage.percentage))
            
            // Wait and monitor
            if (stage.duration != null) {
                val startTime = Instant.now()
                
                while (Duration.between(startTime, Instant.now()) < stage.duration) {
                    val currentMetrics = metrics.collect()
                    
                    // Check for anomalies
                    if (detectAnomalies(currentMetrics)) {
                        logger.error("Anomalies detected in canary deployment")
                        rollbackCanary()
                        throw GradleException("Canary deployment failed")
                    }
                    
                    Thread.sleep(30000) // Check every 30 seconds
                }
                
                logger.lifecycle("Canary stage ${stage.percentage}% completed successfully")
            }
        }
        
        logger.lifecycle("Canary deployment completed successfully")
    }
}

// Monitoring Integration
tasks.register("deployWithMonitoring") {
    description = "Deploy with integrated monitoring and alerting"
    
    dependsOn("deployToProduction")
    
    doLast {
        // Configure monitoring
        val monitoringConfig = MonitoringConfiguration(
            metricsEndpoint = "https://metrics.company.com",
            alertingWebhook = "https://alerts.company.com/webhook",
            thresholds = mapOf(
                "error_rate" to 0.01,
                "response_time_p99" to 1000,
                "cpu_usage" to 0.8
            )
        )
        
        // Start monitoring
        val monitor = startMonitoring(monitoringConfig)
        
        // Wait for stabilization
        val stabilizationPeriod = Duration.ofMinutes(15)
        val endTime = Instant.now().plus(stabilizationPeriod)
        
        while (Instant.now().isBefore(endTime)) {
            val metrics = monitor.getCurrentMetrics()
            
            monitoringConfig.thresholds.forEach { (metric, threshold) ->
                val value = metrics[metric] as Double
                if (value > threshold) {
                    sendAlert("Metric $metric exceeded threshold: $value > $threshold")
                    
                    if (shouldRollback(metric, value)) {
                        executeRollback()
                        throw GradleException("Deployment rolled back due to $metric violation")
                    }
                }
            }
            
            Thread.sleep(60000) // Check every minute
        }
        
        logger.lifecycle("Deployment monitoring completed successfully")
    }
}

// Rollback Task
tasks.register("rollback") {
    description = "Rollback to previous deployment"
    
    doLast {
        val currentVersion = getCurrentDeployedVersion()
        val previousVersion = getPreviousVersion(currentVersion)
        
        logger.lifecycle("Rolling back from $currentVersion to $previousVersion")
        
        // Retrieve previous artifact
        val previousArtifact = downloadArtifact(previousVersion)
        
        // Deploy previous version
        deployArtifact(previousArtifact)
        
        // Verify rollback
        waitForHealthCheck()
        runSmokeTests()
        
        // Log rollback event
        logRollbackEvent(currentVersion, previousVersion, "Manual rollback initiated")
        
        logger.lifecycle("Rollback to $previousVersion completed")
    }
}