Elysia Tools

Parcourez outils, exemples, explications visuelles et guides thématiques dans un espace clair.

Catégories populaires

Dossiers

Langue
ZHDERUPTENFRES

Elysia Tools

Navigation mobile

CI/CD

Exemples CircleCI Configuration

Exemples de configuration CircleCI incluant workflows, orbs, caching et stratégies de déploiement avancées

Exemples

Entrées de cette collection

Code sourcetextSimple

CircleCI Configuration de Base

Configuration CircleCI simple avec jobs de construction, test et déploiement pour application Node.js

Difficulté

3/10

Temps estimé

15 min

Étiquettes

circleci, nodejs, workflow, testing

Prérequis

CircleCI basics, YAML syntax, CI/CD concepts

text
# .circleci/config.yml - Basic CircleCI Configuration

version: 2.1

# Define reusable executor
executors:
  node-executor:
    docker:
      - image: cimg/node:18.17
      - image: cimg/postgres:15
        environment:
          POSTGRES_USER: test_user
          POSTGRES_PASSWORD: test_password
          POSTGRES_DB: test_db
    working_directory: ~/project
    resource_class: medium

# Define job templates
commands:
  setup-node:
    description: "Setup Node.js environment"
    parameters:
      cache-key:
        type: string
        default: "node-v1-{{ checksum "package-lock.json" }}"
    steps:
      - restore_cache:
          keys:
            - << parameters.cache-key >>
            - node-v1-
      - run:
          name: Install dependencies
          command: npm ci
      - save_cache:
          key: << parameters.cache-key >>
          paths:
            - ~/.npm
            - node_modules

  run-tests:
    description: "Run test suite"
    parameters:
      coverage:
        type: boolean
        default: true
    steps:
      - run:
          name: Run tests
          command: |
            <<# parameters.coverage >>
            npm run test:coverage
            << parameters.coverage >>
            npm run test
      - store_test_results:
          path: test-results
      <<# parameters.coverage >>
      - store_artifacts:
          path: coverage
          destination: coverage-report
      - store_artifacts:
          path: coverage/lcov.info
          destination: coverage-lcov
      <</ parameters.coverage >>

# Job definitions
jobs:
  # Build job
  build:
    executor: node-executor
    steps:
      - checkout
      - setup-node
      - run:
          name: Build application
          command: npm run build
      - persist_to_workspace:
          root: ~/project
          paths:
            - .
      - store_artifacts:
          path: dist
          destination: build-artifacts

  # Lint job
  lint:
    executor: node-executor
    steps:
      - checkout
      - setup-node
      - run:
          name: Run linter
          command: npm run lint
      - store_artifacts:
          path: lint-results.json
          destination: lint-report

  # Unit tests
  test:unit:
    executor: node-executor
    steps:
      - checkout
      - setup-node
      - run-tests:
          coverage: true

  # Integration tests
  test:integration:
    executor: node-executor
    environment:
      DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
      NODE_ENV: test
    steps:
      - checkout
      - setup-node
      - run:
          name: Wait for database
          command: dockerize -wait tcp://localhost:5432 -timeout 1m
      - run:
          name: Run integration tests
          command: npm run test:integration
      - store_test_results:
          path: integration-test-results

  # E2E tests
  test:e2e:
    executor:
      name: node-executor
      resource_class: large
    steps:
      - checkout
      - setup-node
      - run:
          name: Build for E2E tests
          command: npm run build
      - run:
          name: Install Playwright
          command: |
            npx playwright install --with-deps
            npx playwright install-deps
      - run:
          name: Run E2E tests
          command: npx playwright test
      - store_artifacts:
          path: playwright-report
          destination: playwright-report
      - store_test_results:
          path: test-results

  # Security scan
  security:
    executor: node-executor
    steps:
      - checkout
      - setup-node
      - run:
          name: Security audit
          command: |
            npm audit --audit-level=high
            npm audit --json > security-audit.json
      - store_artifacts:
          path: security-audit.json
          destination: security-report

  # Deploy to staging
  deploy:staging:
    executor: node-executor
    environment:
      name: staging
      url: https://staging.example.com
    steps:
      - attach_workspace:
          at: ~/project
      - run:
          name: Deploy to staging
          command: |
            echo "Deploying to staging environment..."
            # Add your deployment commands here
            # Example: scp -r dist/* user@staging-server:/var/www/html/
      - run:
          name: Health check
          command: |
            sleep 30
            curl -f https://staging.example.com/health || exit 1

  # Deploy to production
  deploy:production:
    executor: node-executor
    environment:
      name: production
      url: https://example.com
    steps:
      - attach_workspace:
          at: ~/project
      - run:
          name: Deploy to production
          command: |
            echo "Deploying to production environment..."
            # Add your production deployment commands here
            # Example:
            # aws s3 sync dist/ s3://production-bucket/ --delete
            # aws cloudfront create-invalidation --distribution-id $CLOUDFRONT_ID --paths "/*"
      - run:
          name: Production health check
          command: |
            sleep 60
            curl -f https://example.com/health || exit 1

# Define workflows
workflows:
  version: 2
  # Main workflow
  build-and-deploy:
    jobs:
      - build
      - lint:
          requires:
            - build
      - test:unit:
          requires:
            - build
      - test:integration:
          requires:
            - build
      - test:e2e:
          requires:
            - build
      - security:
          requires:
            - build
      - hold-for-approval:
          type: approval
          requires:
            - lint
            - test:unit
            - test:integration
            - test:e2e
            - security
          filters:
            branches:
              only:
                - main
      - deploy:staging:
          requires:
            - hold-for-approval
          filters:
            branches:
              only:
                - main
      - deploy:production:
          requires:
            - deploy:staging
          filters:
            branches:
              only:
                - main

  # Nightly workflow
  nightly:
    triggers:
      - schedule:
          cron: "0 2 * * *"  # Run at 2 AM UTC
          filters:
            branches:
              only:
                - main
    jobs:
      - build
      - test:unit:
          requires:
            - build
      - test:integration:
          requires:
            - build
      - security:
          requires:
            - build

  # Feature branch workflow
  feature-branch:
    jobs:
      - build
      - lint:
          requires:
            - build
      - test:unit:
          requires:
            - build
      - test:integration:
          requires:
            - build
      filters:
        branches:
          ignore:
            - main
            - staging
            - production
Code sourcetextIntermédiaire

CircleCI Workflows Avancés avec Orbs

Configuration CircleCI avancée utilisant orbs, configuration dynamique et stratégies de déploiement complexes

Difficulté

7/10

Temps estimé

30 min

Étiquettes

circleci, orbs, kubernetes, blue-green, deployment

Prérequis

CircleCI advanced, Docker, Kubernetes, Helm, AWS EKS

text
# .circleci/config.yml - Advanced Configuration with Orbs

version: 2.1

# Import official orbs
orbs:
  # Node.js orb for Node.js specific commands
  node: circleci/node@5.1.0

  # Docker orb for Docker operations
  docker: circleci/docker@2.4.0

  # AWS orb for AWS deployments
  aws: circleci/aws@3.0.0

  # Slack orb for notifications
  slack: circleci/slack@4.10.1

  # Helm orb for Kubernetes deployments
  helm: circleci/helm@1.4.0

# Custom commands
commands:
  setup-environment:
    description: "Setup environment variables and configuration"
    parameters:
      environment:
        type: string
        default: "development"
    steps:
      - run:
          name: Setup environment
          command: |
            echo "Setting up environment: << parameters.environment >>"
            echo "NODE_ENV=<< parameters.environment >>" >> $BASH_ENV
            echo "BUILD_NUMBER=$CIRCLE_BUILD_NUM" >> $BASH_ENV
            echo "BRANCH_NAME=$CIRCLE_BRANCH" >> $BASH_ENV
            echo "COMMIT_SHA=$CIRCLE_SHA1" >> $BASH_ENV
            echo "CI=true" >> $BASH_ENV

  deploy-notification:
    description: "Send deployment notification"
    parameters:
      environment:
        type: string
      status:
        type: string
        default: "started"
    steps:
      - slack/notify:
          event: always
          template: basic_success_1
          channel: '#deployments'
          custom: |
            {
              "text": "🚀 Deployment << parameters.status >> for << parameters.environment >>",
              "attachments": [
                {
                  "color": "<< parameters.status >>" == "completed" ? "good" : "warning",
                  "fields": [
                    {
                      "title": "Branch",
                      "value": "$CIRCLE_BRANCH",
                      "short": true
                    },
                    {
                      "title": "Commit",
                      "value": "$CIRCLE_SHA1",
                      "short": true
                    },
                    {
                      "title": "Build URL",
                      "value": "<$CIRCLE_BUILD_URL|View Build>",
                      "short": false
                    }
                  ]
                }
              ]
            }

# Custom executors
executors:
  node-executor:
    docker:
      - image: cimg/node:18.17
    working_directory: ~/project
    resource_class: medium

  docker-executor:
    machine:
      image: ubuntu-2204:2023.04.2
    resource_class: medium

  large-executor:
    docker:
      - image: cimg/node:18.17
    resource_class: large

# Job definitions
jobs:
  # Build job with caching and optimization
  build:
    executor: node-executor
    steps:
      - checkout
      - setup-environment:
          environment: production
      - node/install-packages:
          cache-version: v1
          pkg-manager: npm
      - run:
          name: Build application
          command: |
            npm run build
            npm run analyze
      - persist_to_workspace:
          root: ~/project
          paths:
            - dist/
            - node_modules/
            - package.json
            - package-lock.json
      - store_artifacts:
          path: dist/
          destination: build-artifacts
      - store_artifacts:
          path: bundle-analysis.html
          destination: bundle-analysis

  # Multi-environment testing
  test-matrix:
    parameters:
      node-version:
        type: string
      test-type:
        type: enum
        enum: ["unit", "integration", "e2e"]
    executor:
      name: node-executor
      docker:
        - image: cimg/node:<< parameters.node-version >>
    steps:
      - checkout
      - setup-environment:
          environment: test
      - node/install-packages:
          cache-version: "v1-<< parameters.node-version >>"
      - when:
          condition:
            equal: [ unit, << parameters.test-type >> ]
          steps:
            - run:
                name: Run unit tests
                command: npm run test:unit
            - store_test_results:
                path: test-results
            - store_artifacts:
                path: coverage/
                destination: coverage-report
      - when:
          condition:
            equal: [ integration, << parameters.test-type >> ]
          steps:
            - run:
                name: Run integration tests
                command: npm run test:integration
            - store_test_results:
                path: integration-test-results
      - when:
          condition:
            equal: [ e2e, << parameters.test-type >> ]
          steps:
            - run:
                name: Install Playwright
                command: |
                  npx playwright install --with-deps
                  npx playwright install-deps
            - run:
                name: Build application
                command: npm run build
            - run:
                name: Run E2E tests
                command: npx playwright test
            - store_artifacts:
                path: playwright-report
                destination: playwright-report

  # Docker build and push
  docker-build:
    executor: docker-executor
    parameters:
      image-name:
        type: string
      tag:
        type: string
        default: "$CIRCLE_SHA1"
    steps:
      - checkout
      - setup-environment
      - docker/check:
          docker-username: DOCKER_USERNAME
          docker-password: DOCKER_PASSWORD
      - docker/build:
          image: << parameters.image-name >>
          tag: << parameters.tag >>
          path: .
          docker-context: .
          extra-build-args: |
            --build-arg BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
            --build-arg VCS_REF=$CIRCLE_SHA1
            --build-arg VERSION=<< parameters.tag >>
      - docker/push:
          image: << parameters.image-name >>
          tag: << parameters.tag >>

  # Security scanning
  security-scan:
    executor: node-executor
    parallelism: 2
    steps:
      - checkout
      - setup-environment
      - node/install-packages
      - run:
          name: Security audit
          command: |
            npm audit --audit-level=high --json > npm-audit.json || true
            npm audit --audit-level=high
      - run:
          name: SAST scan
          command: |
            npm install -g semgrep
            semgrep --config=auto --json --output=semgrep-report.json .
      - store_artifacts:
          path: npm-audit.json
          destination: npm-security-audit
      - store_artifacts:
          path: semgrep-report.json
          destination: sast-report

  # Kubernetes deployment
  deploy:k8s:
    executor: docker-executor
    parameters:
      environment:
        type: string
      namespace:
        type: string
      helm-chart:
        type: string
        default: "./helm/app"
    steps:
      - checkout
      - setup-environment:
          environment: << parameters.environment >>
      - aws-eks/update-kubeconfig:
          aws-region: AWS_REGION
          cluster-name: EKS_CLUSTER_NAME
          install-kubectl: true
      - helm/install-helm-client:
          version: v3.12.0
      - run:
          name: Deploy with Helm
          command: |
            helm upgrade --install app-<< parameters.namespace >> \
              << parameters.helm-chart >> \
              --namespace << parameters.namespace >> \
              --create-namespace \
              --set image.tag=$CIRCLE_SHA1 \
              --set environment=<< parameters.environment >> \
              --set ingress.hosts[0].host=<< parameters.namespace >>.example.com \
              --wait --timeout=10m
      - run:
          name: Health check
          command: |
            sleep 60
            kubectl wait --for=condition=ready pod -l app=app-<< parameters.namespace >> -n << parameters.namespace >> --timeout=300s

  # Blue-green deployment
  deploy:blue-green:
    executor: docker-executor
    parameters:
      environment:
        type: string
      namespace:
        type: string
    steps:
      - checkout
      - setup-environment:
          environment: << parameters.environment >>
      - aws-eks/update-kubeconfig:
          aws-region: AWS_REGION
          cluster-name: EKS_CLUSTER_NAME
          install-kubectl: true
      - run:
          name: Blue-green deployment
          command: |
            # Determine current active color
            CURRENT_COLOR=$(kubectl get service app-<< parameters.namespace >> -n << parameters.namespace >> -o jsonpath='{.spec.selector.color}' || echo "blue")
            NEW_COLOR="blue"
            if [ "$CURRENT_COLOR" = "blue" ]; then
              NEW_COLOR="green"
            fi

            echo "Current color: $CURRENT_COLOR"
            echo "New color: $NEW_COLOR"

            # Deploy new version with new color
            helm upgrade --install app-<< parameters.namespace >>-$NEW_COLOR ./helm/app \
              --namespace << parameters.namespace >> \
              --set image.tag=$CIRCLE_SHA1 \
              --set color=$NEW_COLOR \
              --set environment=<< parameters.environment >>

            # Wait for new deployment to be ready
            kubectl rollout status deployment/app-<< parameters.namespace >>-$NEW_COLOR -n << parameters.namespace >> --timeout=600s

            # Health check
            sleep 30
            kubectl port-forward -n << parameters.namespace >> service/app-<< parameters.namespace >>-$NEW_COLOR 8080:80 &
            PORT_FORWARD_PID=$!
            sleep 10

            # Perform health check
            if curl -f http://localhost:8080/health; then
              echo "Health check passed"
              kill $PORT_FORWARD_PID

              # Switch traffic to new version
              kubectl patch service app-<< parameters.namespace >> -n << parameters.namespace >> -p '{"spec":{"selector":{"color":"'$NEW_COLOR'"}}}'

              echo "Traffic switched to $NEW_COLOR version"

              # Wait and verify
              sleep 30
              kubectl port-forward -n << parameters.namespace >> service/app-<< parameters.namespace >> 8080:80 &
              PORT_FORWARD_PID=$!
              sleep 10

              if curl -f http://localhost:8080/health; then
                echo "Deployment successful"
                kill $PORT_FORWARD_PID

                # Clean up old version
                helm uninstall app-<< parameters.namespace >>-$CURRENT_COLOR -n << parameters.namespace >> || true
              else
                echo "Health check failed after switch, rolling back"
                kill $PORT_FORWARD_PID
                kubectl patch service app-<< parameters.namespace >> -n << parameters.namespace >> -p '{"spec":{"selector":{"color":"'$CURRENT_COLOR'"}}}'
                helm uninstall app-<< parameters.namespace >>-$NEW_COLOR -n << parameters.namespace >>
                exit 1
              fi
            else
              echo "Health check failed, rolling back"
              kill $PORT_FORWARD_PID
              helm uninstall app-<< parameters.namespace >>-$NEW_COLOR -n << parameters.namespace >>
              exit 1
            fi

  # Performance testing
  performance-test:
    executor: large-executor
    parameters:
      environment:
        type: string
        default: "staging"
    steps:
      - checkout
      - setup-environment:
          environment: << parameters.environment >>
      - node/install-packages
      - run:
          name: Install Artillery
          command: npm install -g artillery
      - run:
          name: Run performance test
          command: |
            artillery run tests/performance/load-test.yml --output performance-results.json
            artillery report performance-results.json --output performance-report.html
      - store_artifacts:
          path: performance-results.json
          destination: performance-results
      - store_artifacts:
          path: performance-report.html
          destination: performance-report

# Workflows
workflows:
  version: 2

  # Main development workflow
  build-and-deploy:
    jobs:
      # Build application
      - build

      # Parallel test matrix
      - test-matrix:
          matrix:
            parameters:
              node-version: ["16", "18", "20"]
              test-type: ["unit"]
          requires:
            - build

      - test-matrix:
          matrix:
            parameters:
              node-version: ["18"]
              test-type: ["integration", "e2e"]
          requires:
            - build

      # Security scanning
      - security-scan:
          requires:
            - build

      # Docker build
      - docker-build:
          matrix:
            parameters:
              image-name: ["$DOCKER_REGISTRY/app", "$DOCKER_REGISTRY/nginx"]
          requires:
            - build
            - test-matrix
            - security-scan

      # Performance testing for staging
      - performance-test:
          environment: staging
          requires:
            - docker-build
          filters:
            branches:
              only:
                - main

      # Deployment approval and deployment
      - hold-for-staging-approval:
          type: approval
          requires:
            - docker-build
            - security-scan
          filters:
            branches:
              only:
                - main

      - deploy:k8s:
          name: deploy-staging
          environment: staging
          namespace: staging
          requires:
            - hold-for-staging-approval

      - staging-health-check:
          executor: node-executor
          steps:
            - run:
                name: Staging health check
                command: |
                  sleep 120
                  curl -f https://staging.example.com/health || exit 1
          requires:
            - deploy-staging

      - hold-for-production-approval:
          type: approval
          requires:
            - deploy-staging
            - staging-health-check
            - performance-test
          filters:
            branches:
              only:
                - main

      - deploy:blue-green:
          name: deploy-production
          environment: production
          namespace: production
          requires:
            - hold-for-production-approval

      - production-health-check:
          executor: node-executor
          steps:
            - run:
                name: Production health check
                command: |
                  sleep 300
                  curl -f https://example.com/health || exit 1
          requires:
            - deploy-production

  # Release workflow
  release:
    jobs:
      - build
      - docker-build:
          matrix:
            parameters:
              image-name: ["$DOCKER_REGISTRY/app"]
              tag: ["$CIRCLE_TAG"]
          requires:
            - build
          filters:
            branches:
              ignore: /.*/
            tags:
              only: /^v[0-9]+(\.[0-9]+)*$/

  # Scheduled maintenance workflow
  scheduled-maintenance:
    triggers:
      - schedule:
          cron: "0 3 * * 6"  # Every Saturday at 3 AM UTC
          filters:
            branches:
              only:
                - main
    jobs:
      - build
      - security-scan:
          requires:
            - build
      - performance-test:
          environment: production
          requires:
            - build
      - slack/notify:
          channel: '#maintenance'
          event: pass
          template: basic_success_1
          custom: |
            {
              "text": "🔧 Scheduled maintenance completed",
              "attachments": [
                {
                  "color": "good",
                  "fields": [
                    {
                      "title": "Build Number",
                      "value": "$CIRCLE_BUILD_NUM",
                      "short": true
                    },
                    {
                      "title": "Results",
                      "value": "Security scan and performance tests passed",
                      "short": true
                    }
                  ]
                }
              ]
            }

  # Emergency rollback workflow
  emergency-rollback:
    jobs:
      - hold-for-rollback-approval:
          type: approval
          filters:
            branches:
              only:
                - main
      - deploy:k8s:
          name: rollback-production
          environment: production
          namespace: production
          helm-chart: "./helm/app"
          requires:
            - hold-for-rollback-approval
          steps:
            - checkout
            - setup-environment:
                environment: production
            - aws-eks/update-kubeconfig:
                aws-region: AWS_REGION
                cluster-name: EKS_CLUSTER_NAME
                install-kubectl: true
            - helm/install-helm-client:
                version: v3.12.0
            - run:
                name: Rollback to previous version
                command: |
                  helm rollback app-production -n production --wait --timeout=300s
                  kubectl rollout status deployment/app-production -n production --timeout=300s
            - run:
                name: Verify rollback
                command: |
                  sleep 60
                  kubectl port-forward -n production service/app-production 8080:80 &
                  PORT_FORWARD_PID=$!
                  sleep 10
                  curl -f http://localhost:8080/health || exit 1
                  kill $PORT_FORWARD_PID
                  echo "Rollback verified successfully"
Code sourcetextComplexe

CircleCI Workflows Monorepo

Configuration monorepo complexe avec filtrage de chemin, génération dynamique de jobs et workflows conditionnels

Difficulté

9/10

Temps estimé

45 min

Étiquettes

circleci, monorepo, dynamic, path filtering, conditional

Prérequis

Advanced CircleCI, Monorepo architecture, Docker, Kubernetes, Git workflows

text
# .circleci/config.yml - Monorepo Configuration with Dynamic Workflows

version: 2.1

# Import orbs
orbs:
  node: circleci/node@5.1.0
  docker: circleci/docker@2.4.0
  aws: circleci/aws@3.0.0
  gh: circleci/github@0.2.0

# Global parameters and commands
parameters:
  app_name:
    type: string
    default: "my-monorepo-app"

  docker_registry:
    type: string
    default: "docker.io/myorg"

commands:
  detect-changed-packages:
    description: "Detect which packages have changed"
    parameters:
      base-branch:
        type: string
        default: "main"
    steps:
      - run:
          name: Detect changed packages
          command: |
            # Get list of changed files
            if [ "$CIRCLE_BRANCH" = "main" ]; then
              # For main branch, compare with previous commit
              BASE_COMMIT=$(git rev-parse HEAD^1)
            else
              # For feature branches, compare with main
              BASE_COMMIT=$(git merge-base origin/<< parameters.base-branch >> HEAD)
            fi

            echo "Base commit: $BASE_COMMIT"

            # Get changed files
            CHANGED_FILES=$(git diff --name-only $BASE_COMMIT HEAD)
            echo "Changed files:"
            echo "$CHANGED_FILES"

            # Detect affected packages
            AFFECTED_PACKAGES=""
            for file in $CHANGED_FILES; do
              if [[ $file == packages/* ]]; then
                PACKAGE=$(echo $file | cut -d'/' -f1-2)
                if [[ $AFFECTED_PACKAGES != *$PACKAGE* ]]; then
                  AFFECTED_PACKAGES="$AFFECTED_PACKAGES $PACKAGE"
                fi
              fi
            done

            echo "Affected packages: $AFFECTED_PACKAGES"

            # Generate matrix parameters
            MATRIX_CONFIG="{"
            FIRST=true
            for package in $AFFECTED_PACKAGES; do
              if [ "$FIRST" = true ]; then
                FIRST=false
              else
                MATRIX_CONFIG="$MATRIX_CONFIG,"
              fi
              PACKAGE_NAME=$(basename $package)
              MATRIX_CONFIG="$MATRIX_CONFIG"$PACKAGE_NAME":{"path":"$package","name":"$PACKAGE_NAME"}"
            done
            MATRIX_CONFIG="$MATRIX_CONFIG}"

            echo "Matrix config: $MATRIX_CONFIG"

            # Save to file for persistence
            echo "$MATRIX_CONFIG" > /tmp/matrix-config.json

            # Create environment file
            echo "export AFFECTED_PACKAGES='$AFFECTED_PACKAGES'" >> $BASH_ENV
            echo "export MATRIX_CONFIG_FILE='/tmp/matrix-config.json'" >> $BASH_ENV

  build-package:
    description: "Build a specific package"
    parameters:
      package-path:
        type: string
      package-name:
        type: string
      node-version:
        type: string
        default: "18"
    steps:
      - checkout
      - run:
          name: Build << parameters.package-name >>
          command: |
            cd << parameters.package-path >>
            echo "Building package: << parameters.package-name >>"
            echo "Node version: << parameters.node-version >>"
            echo "Package path: << parameters.package-path >>"

            # Use nvm to switch Node versions if needed
            if command -v nvm &> /dev/null; then
              nvm use << parameters.node-version >> || nvm install << parameters.node-version >>
            fi

            npm ci
            npm run build

            echo "Build completed for << parameters.package-name >>"
      - persist_to_workspace:
          root: ~/project
          paths:
            - << parameters.package-path >>/dist
            - << parameters.package-path >>/build
            - << parameters.package-path >>/lib

  test-package:
    description: "Test a specific package"
    parameters:
      package-path:
        type: string
      package-name:
        type: string
      test-type:
        type: enum
        enum: ["unit", "integration", "e2e"]
    steps:
      - attach_workspace:
          at: ~/project
      - run:
          name: Run << parameters.test-type >> tests for << parameters.package-name >>
          command: |
            cd << parameters.package-path >>
            echo "Running << parameters.test-type >> tests for << parameters.package-name >>"

            case "<< parameters.test-type >>" in
              "unit")
                npm run test:unit || npm test
                ;;
              "integration")
                npm run test:integration
                ;;
              "e2e")
                npm run build
                npm run test:e2e
                ;;
            esac
      - store_test_results:
          path: << parameters.package-path >>/test-results
      - when:
          condition:
            equal: [ unit, << parameters.test-type >> ]
          steps:
            - store_artifacts:
                path: << parameters.package-path >>/coverage
                destination: << parameters.package-name >>-coverage

# Executors
executors:
  node-executor:
    docker:
      - image: cimg/node:18.17
    working_directory: ~/project
    resource_class: medium

  large-executor:
    docker:
      - image: cimg/node:18.17
    working_directory: ~/project
    resource_class: large

  docker-executor:
    machine:
      image: ubuntu-2204:2023.04.2
    resource_class: medium

# Job templates
jobs:
  # Setup and detection job
  setup-and-detect:
    executor: node-executor
    steps:
      - checkout
      - detect-changed-packages
      - persist_to_workspace:
          root: ~/project
          paths:
            - /tmp/matrix-config.json

  # Dynamic build job
  build-packages:
    executor: node-executor
    parameters:
      package-path:
        type: string
      package-name:
        type: string
      node-version:
        type: string
        default: "18"
    steps:
      - build-package:
          package-path: << parameters.package-path >>
          package-name: << parameters.package-name >>
          node-version: << parameters.node-version >>

  # Dynamic test job
  test-packages:
    executor: node-executor
    parameters:
      package-path:
        type: string
      package-name:
        type: string
      test-type:
        type: enum
        enum: ["unit", "integration", "e2e"]
    steps:
      - test-package:
          package-path: << parameters.package-path >>
          package-name: << parameters.package-name >>
          test-type: << parameters.test-type >>

  # Build Docker images for packages
  build-docker-images:
    executor: docker-executor
    parameters:
      package-name:
        type: string
      dockerfile-path:
        type: string
        default: "Dockerfile"
    steps:
      - checkout
      - docker/check:
          docker-username: DOCKER_USERNAME
          docker-password: DOCKER_PASSWORD
      - run:
          name: Build Docker image for << parameters.package-name >>
          command: |
            echo "Building Docker image for << parameters.package-name >>"

            # Check if Dockerfile exists
            DOCKERFILE_PATH="<< parameters.package-name >>/<< parameters.dockerfile-path >>"
            if [ ! -f "$DOCKERFILE_PATH" ]; then
              echo "Dockerfile not found at $DOCKERFILE_PATH, skipping"
              exit 0
            fi

            # Build and push image
            IMAGE_NAME="<< parameters.docker_registry >>/<< parameters.package-name >>"
            IMAGE_TAG="$CIRCLE_SHA1"

            docker build \
              -t "$IMAGE_NAME:$IMAGE_TAG" \
              -t "$IMAGE_NAME:latest" \
              -f "$DOCKERFILE_PATH" \
              "<< parameters.package-name >>/"

            echo "Image built: $IMAGE_NAME:$IMAGE_TAG"

            # Push to registry
            docker push "$IMAGE_NAME:$IMAGE_TAG"
            docker push "$IMAGE_NAME:latest"

            echo "Image pushed: $IMAGE_NAME:$IMAGE_TAG"

  # Deploy specific package to Kubernetes
  deploy-package:
    executor: docker-executor
    parameters:
      package-name:
        type: string
      environment:
        type: string
        default: "staging"
      namespace:
        type: string
        default: "staging"
    steps:
      - checkout
      - aws-eks/update-kubeconfig:
          aws-region: AWS_REGION
          cluster-name: EKS_CLUSTER_NAME
          install-kubectl: true
      - run:
          name: Deploy << parameters.package-name >> to << parameters.environment >>
          command: |
            echo "Deploying << parameters.package-name >> to << parameters.environment >>"

            # Check if Helm chart exists
            HELM_CHART_PATH="<< parameters.package-name >>/helm"
            if [ ! -d "$HELM_CHART_PATH" ]; then
              echo "Helm chart not found at $HELM_CHART_PATH, using generic deployment"

              # Generic deployment
              cat > << parameters.package-name >>-deployment.yaml << EOF
            apiVersion: apps/v1
            kind: Deployment
            metadata:
              name: << parameters.package-name >>
              namespace: << parameters.namespace >>
            spec:
              replicas: 2
              selector:
                matchLabels:
                  app: << parameters.package-name >>
              template:
                metadata:
                  labels:
                    app: << parameters.package-name >>
                spec:
                  containers:
                  - name: << parameters.package-name >>
                    image: << parameters.docker_registry >>/<< parameters.package-name >>:$CIRCLE_SHA1
                    ports:
                    - containerPort: 3000
                    env:
                    - name: NODE_ENV
                      value: "<< parameters.environment >>"
            EOF

              kubectl apply -f << parameters.package-name >>-deployment.yaml
              kubectl rollout status deployment/<< parameters.package-name >> -n << parameters.namespace >> --timeout=300s
            else
              # Deploy with Helm
              helm upgrade --install << parameters.package-name >> \
                "$HELM_CHART_PATH" \
                --namespace << parameters.namespace >> \
                --create-namespace \
                --set image.tag=$CIRCLE_SHA1 \
                --set environment=<< parameters.environment >> \
                --set service.name=<< parameters.package-name >> \
                --wait --timeout=600s
            fi

            echo "Deployment completed for << parameters.package-name >>"

  # Integration test across packages
  integration-test-cross-package:
    executor: large-executor
    steps:
      - checkout
      - run:
          name: Setup test environment
          command: |
            echo "Setting up cross-package integration test environment"

            # Install dependencies
            npm ci

            # Start all services
            docker-compose -f docker-compose.test.yml up -d

            # Wait for services to be ready
            sleep 60

            # Check service health
            for service in frontend backend api-gateway; do
              echo "Checking $service health..."
              timeout 60 bash -c 'until curl -f http://localhost:$(docker port $service 3000 | cut -d: -f2)/health; do sleep 2; done'
            done
      - run:
          name: Run cross-package integration tests
            command: |
              echo "Running cross-package integration tests"

              # Run integration tests that span multiple packages
              npm run test:integration:cross-package

              echo "Cross-package integration tests completed"
      - store_test_results:
          path: cross-package-test-results
      - store_artifacts:
          path: integration-test-logs
          destination: integration-logs
      - run:
          name: Cleanup test environment
          command: |
            docker-compose -f docker-compose.test.yml down -v
            echo "Test environment cleaned up"

  # Performance test specific package
  performance-test-package:
    executor: large-executor
    parameters:
      package-name:
        type: string
      environment:
        type: string
        default: "staging"
    steps:
      - checkout
      - run:
          name: Install Artillery
          command: npm install -g artillery
      - run:
          name: Performance test for << parameters.package-name >>
          command: |
            echo "Running performance test for << parameters.package-name >>"

            # Determine target URL based on environment
            case "<< parameters.environment >>" in
              "staging")
                TARGET_URL="https://staging.example.com/<< parameters.package-name >>"
                ;;
              "production")
                TARGET_URL="https://example.com/<< parameters.package-name >>"
                ;;
              *)
                TARGET_URL="http://localhost:3000"
                ;;
            esac

            echo "Target URL: $TARGET_URL"

            # Create performance test config
            cat > performance-test.yml << EOF
            config:
              target: '$TARGET_URL'
              phases:
                - duration: 60
                  arrivalRate: 10
                - duration: 120
                  arrivalRate: 50
                - duration: 60
                  arrivalRate: 100
              payloads:
                path: "payloads.csv"
                fields:
                  - "endpoint"
              processor: "function (params) { return params.target + params.endpoint; }"
            scenarios:
              - name: "Load test for << parameters.package-name >>"
                weight: 100
                flow:
                  - get:
                      url: "/health"
                  - think: 1
                  - get:
                      url: "/api/data"
            EOF

            # Run performance test
            artillery run performance-test.yml --output << parameters.package-name >>-performance-results.json

            # Generate report
            artillery report << parameters.package-name >>-performance-results.json --output << parameters.package-name >>-performance-report.html
      - store_artifacts:
          path: << parameters.package-name >>-performance-results.json
          destination: << parameters.package-name >>-performance-results
      - store_artifacts:
          path: << parameters.package-name >>-performance-report.html
          destination: << parameters.package-name >>-performance-report

# Workflows
workflows:
  version: 2

  # Main monorepo workflow
  monorepo-pipeline:
    jobs:
      # Setup and detect changes
      - setup-and-detect

      # Dynamic build jobs based on changed packages
      - build-packages:
          matrix:
            parameters:
              package-path: ["packages/frontend", "packages/backend", "packages/api-gateway", "packages/shared"]
              package-name: ["frontend", "backend", "api-gateway", "shared"]
              node-version: ["18"]
          requires:
            - setup-and-detect

      # Dynamic test jobs
      - test-packages:
          matrix:
            parameters:
              package-path: ["packages/frontend", "packages/backend", "packages/api-gateway", "packages/shared"]
              package-name: ["frontend", "backend", "api-gateway", "shared"]
              test-type: ["unit"]
          requires:
            - build-packages

      - test-packages:
          matrix:
            parameters:
              package-path: ["packages/backend", "packages/api-gateway"]
              package-name: ["backend", "api-gateway"]
              test-type: ["integration"]
          requires:
            - build-packages

      - test-packages:
          matrix:
            parameters:
              package-path: ["packages/frontend"]
              package-name: ["frontend"]
              test-type: ["e2e"]
          requires:
            - build-packages

      # Build Docker images
      - build-docker-images:
          matrix:
            parameters:
              package-name: ["frontend", "backend", "api-gateway"]
          requires:
            - test-packages
          filters:
            branches:
              only:
                - main
                - develop
                - /^release\/.*/

      # Cross-package integration tests
      - integration-test-cross-package:
          requires:
            - build-packages
          filters:
            branches:
              only:
                - main
                - develop

      # Deploy to staging
      - deploy-package:
          matrix:
            parameters:
              package-name: ["frontend", "backend", "api-gateway"]
              environment: ["staging"]
              namespace: ["staging"]
          requires:
            - build-docker-images
          filters:
            branches:
              only:
                - main
                - develop

      # Performance tests for staging
      - performance-test-package:
          matrix:
            parameters:
              package-name: ["frontend", "backend", "api-gateway"]
              environment: ["staging"]
          requires:
            - deploy-package
          filters:
            branches:
              only:
                - main

      # Hold for production approval
      - hold-for-production-approval:
          type: approval
          requires:
            - integration-test-cross-package
            - deploy-package
            - performance-test-package
          filters:
            branches:
              only:
                - main

      # Deploy to production
      - deploy-package:
          matrix:
            parameters:
              package-name: ["frontend", "backend", "api-gateway"]
              environment: ["production"]
              namespace: ["production"]
          requires:
            - hold-for-production-approval
          filters:
            branches:
              only:
                - main

  # Package-specific workflows
  package-workflows:
    jobs:
      # Frontend specific workflow
      - build-packages:
          name: build-frontend-specific
          package-path: "packages/frontend"
          package-name: "frontend"
          node-version: "18"
          filters:
            branches:
              only:
                - /frontend\/.*/

      - test-packages:
          name: test-frontend-specific
          package-path: "packages/frontend"
          package-name: "frontend"
          test-type: "e2e"
          requires:
            - build-frontend-specific
          filters:
            branches:
              only:
                - /frontend\/.*/

      # Backend specific workflow
      - build-packages:
          name: build-backend-specific
          package-path: "packages/backend"
          package-name: "backend"
          node-version: "18"
          filters:
            branches:
              only:
                - /backend\/.*/

      - test-packages:
          name: test-backend-specific
          package-path: "packages/backend"
          package-name: "backend"
          test-type: "integration"
          requires:
            - build-backend-specific
          filters:
            branches:
              only:
                - /backend\/.*/

  # Nightly monorepo workflow
  nightly-monorepo:
    triggers:
      - schedule:
          cron: "0 2 * * *"  # 2 AM UTC
          filters:
            branches:
              only:
                - main
    jobs:
      - setup-and-detect
      - build-packages:
          matrix:
            parameters:
              package-path: ["packages/frontend", "packages/backend", "packages/api-gateway", "packages/shared"]
              package-name: ["frontend", "backend", "api-gateway", "shared"]
          requires:
            - setup-and-detect
      - test-packages:
          matrix:
            parameters:
              package-path: ["packages/frontend", "packages/backend", "packages/api-gateway", "packages/shared"]
              package-name: ["frontend", "backend", "api-gateway", "shared"]
              test-type: ["unit"]
          requires:
            - build-packages
      - integration-test-cross-package:
          requires:
            - build-packages

  # Release workflow
  release-packages:
    jobs:
      - setup-and-detect
      - build-packages:
          matrix:
            parameters:
              package-path: ["packages/frontend", "packages/backend", "packages/api-gateway", "packages/shared"]
              package-name: ["frontend", "backend", "api-gateway", "shared"]
          requires:
            - setup-and-detect
          filters:
            tags:
              only: /^v[0-9]+(\.[0-9]+)*$/
            branches:
              ignore: /.*/
      - test-packages:
          matrix:
            parameters:
              package-path: ["packages/frontend", "packages/backend", "packages/api-gateway", "packages/shared"]
              package-name: ["frontend", "backend", "api-gateway", "shared"]
              test-type: ["unit"]
          requires:
            - build-packages
          filters:
            tags:
              only: /^v[0-9]+(\.[0-9]+)*$/
            branches:
              ignore: /.*/
      - build-docker-images:
          matrix:
            parameters:
              package-name: ["frontend", "backend", "api-gateway"]
              dockerfile-path: ["Dockerfile"]
          requires:
            - test-packages
          filters:
            tags:
              only: /^v[0-9]+(\.[0-9]+)*$/
            branches:
              ignore: /.*/
      - deploy-package:
          matrix:
            parameters:
              package-name: ["frontend", "backend", "api-gateway"]
              environment: ["production"]
              namespace: ["production"]
          requires:
            - build-docker-images
          filters:
            tags:
              only: /^v[0-9]+(\.[0-9]+)*$/
            branches:
              ignore: /.*/

Outils

Outils souvent utilisés avec cet exemple

Associé

Collections d’exemples associées

Associé

Dossiers associés

Dossier

Déduire un JSON Schema depuis des exemples et des tableurs

Produisez un brouillon de JSON Schema relisible à partir d'exemples JSON représentatifs ou de lignes XLSX, puis examinez types, caractère obligatoire, valeurs nulles et anomalies avant toute adoption contractuelle.

Dossier

Quantification par absorbance et calculs acido-basiques

Changez des lectures d'appareil en concentrations défendables — passez de l'absorbance à la transmittance et retour, résolvez la loi de Beer-Lambert pour la variable manquante, parcourez la chaîne des acides nucléiques de A260 aux microgrammes aux nanomolaires aux copies par microlitre, prédisez le pH depuis les concentrations d'acides et de bases fortes, concevez des tampons par Henderson-Hasselbalch et vérifiez la dissociation par la conductivité molaire.

Dossier

Calculateurs de quantification proteique, cinetique enzymatique et sequence

Reliez proprietes de sequence, estimations BCA et Bradford, unites d'activite, cinetique, inhibition, turnover, efficacite catalytique et affinite de liaison pour une revue educative et de recherche.

Dossier

Modeles pharmacocinetiques pedagogiques et controle des resultats

Explorer les formules pharmacocinetiques, les hypotheses de modele et la coherence des resultats pour l'enseignement ou la QA, sans avis clinique.

Accueil
Outils3212
Exemples593
Visualisations471
Visionneuses de fichiers103
Dossiers239
Étiquettes333
Images, audio et vidéo657

Outils de traitement, conversion et optimisation d’images, d’audio et de vidéo

Maths, dates et finance647

Calculateurs, outils numériques, logique de dates, statistiques et finance

Design et couleur298

Outils de couleur, mise en page, graphisme, style visuel et assistance design

Texte et rédaction209

Outils de rédaction, nettoyage, formatage, extraction et analyse de texte

Développement et Web193

Utilitaires développeur, réseau, débogage Web et assistants d’automatisation

Conversion et encodage175

Outils de conversion de formats, fichiers, archives, unités et encodages

Lancement d’un quiz de prospection et transmission des contacts
Textes commémoratifs : validation familiale et remise pour impression
Habitudes privées : sauvegarde, restauration et partage vérifié
D’un article aux brouillons X et LinkedIn : revue factuelle et livraison
Revue de cours Markdown interactif et livraison hors ligne

© 2026 Elysia Tools. Tous droits réservés.

DocumentationTarifsÀ proposConditions d'utilisationPolitique de confidentialitéCookiesContact

Format Conversion

Convertisseur HCL-YAML

Convertit entre HashiCorp Configuration Language (HCL) et les formats YAML pour les configurations Terraform

Format Conversion

Convertisseur TOML-YAML

Convertit entre les formats TOML et YAML avec prise en charge des structures de données complexes et des fichiers de configuration

Data Processing

Fusionneur YAML

Fusionne plusieurs fichiers YAML avec différentes stratégies (fusion profonde, écrasement, etc.)

Format Conversion

Pont entre formats de configuration : TOML / INI / HCL / .env / Nix / dotenv / ConfigMap / Secret Kubernetes

Convertit des configurations entre dotenv .env, TOML, INI, Java .properties, YAML, JSON, HCL (syntaxe native Terraform/Vagrant) et ensembles d'attributs Nix, et produit des manifestes Kubernetes ConfigMap / Secret ; préserve les gabarits ${VAR} / {{var}} et l'interpolation style envsubst, trace la provenance de l'inférence de types (string/int/float/bool/list), replie les étiquettes de blocs HCL en clés imbriquées, et un diff aller-retour met en évidence les réglages non équivalents (clés perdues, changements de type, valeurs réécrites), avec un YAML adapté aux patches Kustomize.

Format Conversion

Convertisseur YAML-JSON

Convertit entre les formats YAML et JSON

Format Conversion

Formateur YAML

Formate et embelli YAML. Remarque : les commentaires sont perdus (limitation js-yaml)

Development

Diff sémantique de fichiers de configuration

Comparez des configurations JSON, YAML, TOML et dotenv par chemin de clé en ignorant l’ordre et le bruit de formatage.

Development

Visualiseur des differences de configuration denvironnement

Compare des configurations JSON, YAML, TOML et ENV entre environnements en mettant en evidence la derive, les cles manquantes et les pistes de nettoyage.

CI/CD

Exemples GitLab CI

Exemples de configuration GitLab CI/CD incluant les pipelines multi-étapes, caching, artifacts et stratégies de déploiement

Observabilité

Exemples de Traçage Distribué

Exemples complets de traçage distribué utilisant Jaeger, OpenTelemetry et outils d'observabilité modernes

Service Mesh

Exemples de Service Mesh Consul

Exemples de service mesh HashiCorp Consul avec découverte de services, configuration et sécurité

Informatique en nuage

Exemples DigitalOcean

Exemples DigitalOcean incluant Droplets, Kubernetes, Spaces et App Platform

Gestion des journaux

Exemples Elastic Stack (ELK)

Configuration complète Elastic Stack incluant Elasticsearch, Logstash, Kibana et Beats pour gestion et analyse de logs

Informatique en nuage

Exemples Linode Cloud Service

Exemples Linode incluant instances, Object Storage, Load Balancers et Kubernetes