This is in contrast to the **development** stages, where you are constantly changing the code, breaking it and fixing it, stopping and restarting the development server, etc.

## Deployment Strategies { #deployment-strategies }

        TaskProvider<Sync> userguide = tasks.register("userguide", Sync.class, task -> {
            task.setGroup("documentation");
            task.setDescription("Stages rendered user manual documentation.");

            task.from(userguideSinglePageHtml);
            task.from(userguideMultiPage);
            task.into(extension.getUserManual().getStagingRoot().dir("final"));

* the system authenticates the user

* the CLI
* the command line interface

* the server
* the client

* the cloud provider
* the cloud service

* the development
* the development stages

* the dict
* the dictionary
* the enumeration
* the enum
* the enum member

* the encoder
* the decoder
* to encode
* to decode

* the exception
* to raise

Although in FastAPI it's optional, and is used mainly to set headers, cookies, and alternative status codes.

///

### [Molten](https://moltenframework.com/) { #molten }

I discovered Molten in the first stages of building **FastAPI**. And it has quite similar ideas:

* Based on Python type hints.
* Validation and documentation from these types.

        )

    @BeforeEach
    fun setUp() {
        val stepsCapturer = slot<BuildSteps.() -> Unit>()
        every { buildType.steps } returns steps
        every { buildType.stage } returns buildModel.stages[2]
        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

    @Test

* the system authenticates the user

* the CLI
* the command line interface

* the server
* the client

* the cloud provider
* the cloud service

* the development
* the development stages

* the dict
* the dictionary
* the enumeration
* the enum
* the enum member

* the encoder
* the decoder
* to encode
* to decode

* the exception
* to raise

* authorization provider
* 사용자가 인증한다
* 시스템이 사용자를 인증한다

* CLI
* command line interface

* server
* client

* cloud provider
* cloud service

* development
* development stages

* dict
* dictionary
* enumeration
* enum
* enum member

* encoder
* decoder
* encode하다
* decode하다

* exception
* raise하다

* expression
* statement

            stage.flameGraphs.map { createFlameGraphs(model, stage, it) }

        val (topLevelCoverage, allCoverage) = stage.functionalTests.partition { it.testType == TestType.SOAK }
        val topLevelFunctionalTests =
            topLevelCoverage

import model.CIBuildModel
import model.SpecificBuild
import model.Stage

/**
 * Subproject under [StageProject] that groups smoke test build configurations.
 */
class SmokeTestProject(
    model: CIBuildModel,
    stage: Stage,
    smokeBuildTypes: List<OsAwareBaseGradleBuildType>,
) : Project({
        id("${model.projectId}_Stage_${stage.stageName.id}_SmokeTest")

## Images de conteneur { #container-images }

Docker a été l'un des principaux outils pour créer et gérer des **images de conteneur** et des **conteneurs**.

Et il existe un [Docker Hub](https://hub.docker.com/) public avec des **images de conteneur officielles** pré-construites pour de nombreux outils, environnements, bases de données et applications.