Rust : développement sécurisé avec GitLab

Rust s'est imposé comme l'un des langages de programmation les plus appréciés grâce à ses performances, sa mémoire sécurisée et ses fonctionnalités attractives. Alors que l'adoption de Rust continue de croître, de nombreux développeurs recherchent des plateformes CI/CD robustes pour prendre en charge leurs projets Rust.

Pour les équipes de développement qui utilisent Rust, l'attrait de GitLab va bien au-delà du simple hébergement de code. La plateforme offre des capacités CI/CD robustes qui s'alignent parfaitement avec l'accent mis par Rust sur la sécurité, les performances et la fiabilité. GitLab facilite la création de dépôts et l'utilisation de conteneurs Docker prêts à l'emploi pour exécuter des jobs CI personnalisés. Les équipes peuvent facilement configurer des tests automatisés, des compilations multiplateformes et la génération de documentation. L'approche intégrée de la plateforme DevSecOps résonne avec la philosophie de Rust qui consiste à fournir des outils complets prêts à l'emploi.

À propos de l'application de démonstration

Nous nous intéressons à l'impact des taux hypothécaires sur les paiements mensuels et à la difficulté d'acheter une maison dans le contexte actuel, c'est pourquoi nous avons décidé d'écrire un calculateur de prêt hypothécaire en Rust, que nous utiliserons comme exemple tout au long de ce tutoriel. N'hésitez pas à importer ce projet pour mieux suivre la démonstration.

Le calculateur de prêt hypothécaire aidera les utilisateurs à calculer les paiements mensuels d'un prêt hypothécaire, qui incluent le capital, les intérêts, les taxes foncières, l'assurance, l'assurance du prêt hypothécaire privée et les frais d'association de propriétaires. Il fournit une interface graphique moderne et intuitive au moyen du framework egui, ainsi qu'une interface de ligne de commande pour l'exécuter dans le terminal.

Cette application contient un fichier .gitlab-ci.yml qui génère un pipeline, lequel va construire, tester, empaqueter, analyser et déployer le logiciel. Nous examinerons cette définition du pipeline en détail dans les sections ci-dessous.

Compilation et test des applications Rust

Le système CI/CD basé sur Docker de GitLab excelle dans les workflows de développement Rust, car il fournit une base robuste pour la compilation, les tests et les vérifications de qualité du code. Les mécanismes de mise en cache de la plateforme sont particulièrement précieux pour les projets Rust, qui peuvent avoir des temps de compilation longs en raison des processus approfondis d'optimisation et de vérification de sécurité du langage.

Compilation

Les excellentes capacités de compilation croisée de Rust combinées au système CI/CD flexible de GitLab créent une solution puissante pour construire des applications sur plusieurs plateformes. Cette combinaison est particulièrement utile pour les applications Rust qui doivent fonctionner sur divers systèmes d'exploitation et architectures sans impacter les performances ou nécessiter du code spécifique à la plateforme.

Remarque : vous pouvez en apprendre davantage sur le fichier .gitlab-ci.yml en consultant la référence dédiée à la syntaxe YAML CI/CD.

# Cache configuration to speed up builds by reusing dependencies
cache:
  key: $CI_COMMIT_REF_SLUG                               # Use branch name as cache key
  paths:
    - .cargo/                                            # Cache Cargo registry and git dependencies
    - target/                                            # Cache compiled artifacts

# Base template for Rust jobs - shared configuration
.rust-template:
  image: rust:$RUST_VERSION-slim                         # Use slim Rust image for faster downloads
  before_script:
    # Install system dependencies required for building the Rust application
    - apt-get update && apt-get install -y pkg-config libssl-dev libgtk-3-dev libxcb-shape0-dev libxcb-xfixes0-dev

# Template for cross-compilation build jobs
.build-template:
  extends: .rust-template                                # Inherit from rust-template
  stage: build                                           # Execute during build stage
  script:
    - rustup target add $TARGET                          # Add the target platform for cross-compilation
    - cargo build --release --target $TARGET             # Build optimized release binary for target platform

# Build for Linux x86_64 (primary target platform)
build-linux:
  extends: .build-template                               # Use build template configuration
  variables:
    TARGET: x86_64-unknown-linux-gnu                     # Linux 64-bit target
  artifacts:
    paths:
      - target/$TARGET/release/mortgage-calculator       # Save the compiled binary
    expire_in: 1 week                                    # Keep artifacts for 1 week
  allow_failure: false                                   # This build must succeed

# Build for Windows x86_64 (cross-compilation)
build-windows:
  extends: .build-template                               # Use build template configuration
  variables:
    TARGET: x86_64-pc-windows-gnu                        # Windows 64-bit target
  artifacts:
    paths:
      - target/$TARGET/release/mortgage-calculator       # Save the compiled binary
    expire_in: 1 week                                    # Keep artifacts for 1 week
  allow_failure: true                                    # Allow this build to fail (cross-compilation can be tricky)

# Build for macOS x86_64 (cross-compilation)
build-macos:
  extends: .build-template                               # Use build template configuration
  variables:
    TARGET: x86_64-apple-darwin                          # macOS 64-bit target
  artifacts:
    paths:
      - target/$TARGET/release/mortgage-calculator       # Save the compiled binary
    expire_in: 1 week                                    # Keep artifacts for 1 week
  allow_failure: true

Cette configuration GitLab CI définit trois jobs de compilation qui compilent de manière croisée une application de calculateur de prêt hypothécaire Rust pour différentes plateformes :

• build-linux crée un binaire Linux x86_64 (requis pour réussir)
• build-windows crée des binaires Windows (autorisés à échouer)
• build-macos crée des binaires macOS x86_64 (autorisés à échouer)

Toutes les compilations utilisent des templates partagés pour la mise en cache des dépendances et des environnements de compilation cohérents.

Tests

GitLab CI/CD simplifie les tests de code grâce à son système de pipeline intégré qui déclenche automatiquement les suites de tests chaque fois qu'un push du code est effectué vers le dépôt. Les développeurs peuvent définir plusieurs types de tests (tests unitaires, tests d'intégration, linting et vérifications de formatage) dans un seul fichier de configuration .gitlab-ci.yml. Chaque test s'exécute dans des conteneurs Docker isolés pour garantir des environnements cohérents.

  # Run unit tests
test:unit:
  extends: .rust-template                                # Use Rust template configuration
  stage: test                                            # Execute during test stage
  script:
    - cargo test --verbose                               # Run all unit tests with verbose output

# Run integration tests using the compiled binary
test:integration:
  extends: .rust-template                                # Use Rust template configuration
  stage: test                                            # Execute during test stage
  script:
    # Test the compiled binary with sample inputs and verify expected output
    - target/x86_64-unknown-linux-gnu/release/mortgage-calculator --cli calculate --property-value 350000 --down-payment 70000 --interest-rate 5.0 | grep -q "TOTAL MONTHLY PAYMENT"
  needs:
    - build-linux                                        # Depends on Linux build job completing

# Run Clippy linter for code quality checks
test:clippy:
  extends: .rust-template                                # Use Rust template configuration
  stage: test                                            # Execute during test stage
  script:
    - rustup component add clippy                        # Install Clippy linter
    - cargo clippy -- -D warnings                       # Run Clippy and treat warnings as errors
  allow_failure: true                                    # Allow linting failures (can be improved over time)

# Check code formatting
test:format:
  extends: .rust-template                                # Use Rust template configuration
  stage: test                                            # Execute during test stage
  script:
    - rustup component add rustfmt                       # Install Rust formatter
    - cargo fmt -- --check                              # Check if code is properly formatted
  allow_failure: true                                    # Allow formatting failures (can be improved over time)

Cette configuration GitLab CI crée quatre jobs de test qui valident l'application de calculateur de prêt hypothécaire Rust :

• test:unit exécute les tests unitaires
• test:integration exécute le binaire Linux compilé avec des intrants d'exemple pour vérifier la fonctionnalité
• test:clippy effectue le linting de la qualité du code (autorisé à échouer)
• test:format vérifie la conformité du formatage du code (autorisé à échouer)

Registres de paquets et de conteneurs

Le registre de paquets de GitLab fournit une solution sécurisée au partage de bibliothèques internes et de code propriétaire au sein des organisations. Cette fonctionnalité est essentielle pour les entreprises et équipes qui doivent maintenir des artefacts et continuer à utiliser l'écosystème Rust au sens large.

Le registre prend en charge les artefacts génériques avec des contrôles d'accès granulaires en fonction des permissions de projet de GitLab. Les équipes peuvent donc partager des bibliothèques en toute sécurité entre les projets ainsi que respecter la protection de la propriété intellectuelle et les exigences de conformité.

De plus, nous pouvons conteneuriser notre application et stocker les images de conteneur dans le registre des conteneurs intégré de GitLab.

Publication vers le registre de paquets GitLab

Cette section de notre .gitlab-ci.yml démontre comment packager et publier des applications Rust sous forme d'archives tar vers le registre de paquets génériques de GitLab au moyen de l'automatisation CI/CD.

# Package application as tar archive
package:tar:
  image: alpine/curl:8.12.1                             # Lightweight image with curl for uploading
  stage: package                                         # Execute during package stage
  variables:
    PACKAGE_NAME: mortgage-calculator.tar.gz             # Name of the archive file
  script:
    # Create tar archive of the Linux binary
    - tar -czvf $PACKAGE_NAME target/x86_64-unknown-linux-gnu/release/mortgage-calculator
    # Upload archive to GitLab Package Registry using API
    - |
      curl -v --location --header "JOB-TOKEN: $CI_JOB_TOKEN" \
      --upload-file $PACKAGE_NAME \
      "$CI_API_V4_URL/projects/$CI_PROJECT_ID/packages/generic/tar/$CI_COMMIT_BRANCH/$PACKAGE_NAME"
  artifacts:
    paths:
      - target/x86_64-unknown-linux-gnu/release/mortgage-calculator  # Save binary
      - mortgage-calculator.tar.gz                      # Save archive
    expire_in: 1 week                                    # Keep artifacts for 1 week
  needs:
    - build-linux                                        # Depends on Linux build completing

Cette configuration GitLab CI définit un job d'empaquetage package:tar qui crée une archive tar compressée du binaire de calculateur de prêt hypothécaire Linux et l'importe vers le registre de paquets de GitLab, et sauvegarde à la fois le binaire et l'archive comme artefacts de pipeline.

Publication vers le registre de conteneurs GitLab

Le bloc de code ci-dessous montre le processus de création de Dockerfiles et de publication d'images Docker vers le registre de conteneurs de GitLab avec un ajout de tags et une authentification appropriés.

# Package application as Docker image
package:docker:
  image: docker:24.0                                     # Use Docker image for building containers
  stage: package                                         # Execute during package stage
  services:
    - docker:24.0-dind                                   # Docker-in-Docker service for building images
  before_script:
    # Login to GitLab Container Registry
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
  script:
    - docker build -t $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG .  # Build Docker image with commit SHA tag
    - docker tag $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG $DOCKER_IMAGE_NAME:latest  # Also tag as latest
    - docker push $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG  # Push tagged image to registry
    - docker push $DOCKER_IMAGE_NAME:latest             # Push latest image to registry

Cette configuration GitLab CI définit un job d'empaquetage Docker package:docker qui crée une image Docker de l'application de calculateur de prêt hypothécaire, ajoute les tags « commit SHA » et « latest », puis pousse les deux versions avec un tag vers le registre de conteneurs de GitLab.

Scanning de sécurité

Le scanning de sécurité GitLab fournit une protection complète qui va au-delà des garanties de sécurité mémoire intégrées de Rust. Bien que Rust prévienne de nombreuses vulnérabilités de sécurité courantes au moment de la compilation, les applications ont encore besoin de protection contre les vulnérabilités des dépendances, les blocs de code non sécurisés et les problèmes de sécurité logiques.

Les tests statiques de sécurité des applications ([SAST])(https://docs.gitlab.com/user/application_security/sast/) de la plateforme s'intègrent parfaitement avec la chaîne d'outils de Rust et fournissent une analyse de sécurité automatisée dans le pipeline CI/CD. Cette approche proactive détecte les problèmes de sécurité avant qu'ils n'arrivent en production afin de répondre à la fois aux exigences de conformité et aux pratiques de développement sécurisé.

Les fonctionnalités de sécurité complètes de GitLab, y compris les tests SAST, l'analyse des dépendances et la détection des secrets peuvent facilement être implémentées via des modèles, comme illustré ci-dessous.

Remarque : une configuration supplémentaire est requise pour activer les tests SAST pour Rust.

# Include GitLab's security scanning templates for DevSecOps
include:
  - template: Jobs/SAST.gitlab-ci.yml                    # Static Application Security Testing
  - template: Jobs/Dependency-Scanning.latest.gitlab-ci.yml  # Scan dependencies for vulnerabilities
  - template: Jobs/Container-Scanning.gitlab-ci.yml      # Scan Docker containers for vulnerabilities
  - template: Jobs/SAST-IaC.gitlab-ci.yml               # Infrastructure as Code security scanning
  - template: Jobs/Secret-Detection.gitlab-ci.yml        # Detect secrets in source code

Les scanners de sécurité peuvent être configurés de manière similaire à n'importe quel job sur GitLab :

# Configure Semgrep SAST scanning for Rust files
semgrep-sast:
  rules:
    - if: $CI_COMMIT_BRANCH                              # Run on any branch
      exists:
        - "**/*.rs"                                      # Only if Rust files exist
  variables:
    SAST_EXCLUDED_PATHS: ".cargo/**"                     # Exclude Cargo cache from scanning

# Scan Docker container for security vulnerabilities
container_scanning:
  stage: container-security                              # Execute during container-security stage
  variables:
    CS_IMAGE: $DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG      # Image to scan
    CS_DOCKERFILE_PATH: Dockerfile                       # Path to Dockerfile for context
  needs:
    - package:docker                                     # Depends on Docker image being built

Lorsque des vulnérabilités sont détectées dans une merge request (MR), vous pouvez toutes les afficher et utiliser les informations fournies pour les résoudre ou les rejeter.

Vous pouvez également ajouter des stratégies de sécurité pour exiger une approbation avant que du code vulnérable puisse être fusionné, ou pour forcer l'exécution des scanners indépendamment de ce qui se trouve dans le .gitlab-ci.yml.

Vous pouvez trier toutes les vulnérabilités trouvées dans votre branche par défaut au moyen du rapport de vulnérabilités :

Documentation avec GitLab Pages

GitLab Pages fournit une excellente plateforme pour héberger la documentation Rust, car il s'intègre parfaitement avec la génération de documentation intégrée de Cargo. Ce workflow puissant génère et déploie la documentation API, les guides de projet et les exemples automatiquement à chaque modification de code.

La combinaison de cargo doc et GitLab Pages permet aux équipes de maintenir une documentation à jour sans intervention manuelle afin que la documentation soit synchronisée avec les modifications de code. Cette fonctionnalité est particulièrement utile pour les projets Rust où une documentation complète est essentielle pour comprendre les API complexes et les contrats de sécurité.

Déploiement automatisé de la documentation

Le code ci-dessous montre la configuration CI/CD nécessaire pour générer et déployer automatiquement la documentation Rust au moyen de cargo doc et GitLab Pages.

# Generate and publish documentation using GitLab Pages
build-documentation:
  extends: .rust-template                                # Use Rust template configuration
  stage: build                                           # Execute during build stage
  variables:
    GIT_SUBMODULE_STRATEGY: recursive                    # Clone submodules recursively if needed
  pages: true                                            # Enable GitLab Pages deployment
  script:
    - cargo doc --no-deps                                # Generate documentation without dependencies
    - mv target/doc public                               # Move docs to public directory for Pages
  artifacts:
    paths:
      - public                                           # GitLab Pages serves from public directory
  rules:
    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH     # Only run on default branch (main/master)
  environment:
    name: documentation                                  # Environment name for tracking
    url: $CI_PAGES_URL/mortgage_calculator/index.html   # Documentation URL
  allow_failure: true                                    # Allow documentation build to fail

Une fois le job terminé, vous pouvez consulter la documentation déployée en accédant à l'environnement GitLab où il a été déployé.

De cette manière, vous pouvez gérer plusieurs versions de la documentation dans différents environnements. La documentation sera déployée de manière cohérente avec les données de sortie de cargo doc :

Déploiement dans tous les environnements

L'une des plus grandes forces de GitLab est son approche indépendante de l'infrastructure pour le déploiement. Que votre organisation fonctionne sur des serveurs traditionnels sur site, sur des plateformes cloud modernes, sur des environnements hybrides ou sur une infrastructure edge computing, le système CI/CD de GitLab peut déployer des applications Rust de manière harmonieuse dans n'importe quel environnement cible.

La flexibilité de déploiement de GitLab découle de son approche axée sur les conteneurs et de son écosystème d'intégration étendu. La plateforme prend en charge le déploiement sur presque toutes les infrastructures capables d'exécuter des conteneurs, des machines virtuelles ou des applications sur serveur physique dédié. Cette polyvalence est particulièrement utile pour les applications Rust, qui doivent souvent fonctionner dans des environnements allant des systèmes embarqués avec des ressources limitées aux clusters cloud haute performance.

Déploiement dans Kubernetes

GitLab simplifie les déploiements dans Kubernetes avec une intégration de cluster intégrée et des images Docker préconfigurées qui incluent des outils essentiels comme Helm et kubectl. Les équipes de développement n'ont alors plus besoin de configurer des environnements de déploiement complexes.

# Deploy application to Kubernetes cluster
deploy:kubernetes:
  stage: deploy                                          # Execute during deploy stage
  image: registry.gitlab.com/gitlab-org/cluster-integration/helm-install-image:helm-3.10.0-kube-1.24.6-alpine-3.15  # Image with Helm and kubectl
  variables:
    HELM_HOST: "localhost:44134"                         # Helm host configuration
    HELM_DEPLOY_NAME: mortgage-calc-$CI_COMMIT_REF_NAME  # Deployment name based on branch
    HELM_DEPLOY_NAMESPACE: calc-app                      # Kubernetes namespace for deployment
    KUBE_CONTEXT: $CI_PROJECT_PATH:rust-mortgage-calculator  # Kubernetes context to use
  script:
    - kubectl config use-context $KUBE_CONTEXT          # Set the kubectl context
    # Deploy using Helm with custom values and Docker image
    - helm upgrade --install $HELM_DEPLOY_NAME chart -f chart/values.yaml
      --namespace $HELM_DEPLOY_NAMESPACE
      --create-namespace
      --set image=$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG
      --set calc.name=$HELM_DEPLOY_NAME
  needs:
    - package:docker                                     # Depends on Docker image being available

Cette configuration GitLab CI définit un job de déploiement deploy:kubernetes qui utilise Helm pour déployer l'application de calculateur de prêt hypothécaire sur un cluster Kubernetes, avec la création ou la mise à niveau du déploiement dans un espace de nommage dédié avec l'image Docker construite dans l'étape d'empaquetage précédente.

Fonctionnalités d'IA de GitLab Duo

Les fonctionnalités d'IA de GitLab Duo offrent des avantages significatifs pour le développement Rust grâce à des suggestions de code intelligentes et des explications spécifiquement adaptées à la syntaxe et aux modèles uniques du langage. Rust est l'un des langages directement pris en charge de la plateforme GitLab pour chaque IDE et garantit une complétion et une génération de code de haute qualité qui comprend le modèle de propriété de Rust, les principes de sécurité mémoire et les modèles idiomatiques.

Suggestions de code de GitLab Duo

La capacité de GitLab Duo à fournir des suggestions de code en contexte pendant l'écriture aide les équipes de développement à naviguer plus efficacement dans la syntaxe parfois complexe de Rust, à réduire la courbe d'apprentissage pour les nouveaux venus et à accélérer la productivité des développeurs expérimentés.

GitLab Duo Chat

GitLab Duo Chat complète les suggestions de code : il offre une assistance conversationnelle pour expliquer les sections de code Rust, déboguer les erreurs du compilateur et fournir des conseils sur les meilleures pratiques. Cette aide est particulièrement précieuse dans le développement Rust où les messages d'erreur du compilateur, bien qu'utiles, peuvent parfois surcharger les équipes de développement habituées à d'autres langages.

L'IA peut aider à interpréter les messages d'erreur détaillés de Rust et suggérer des corrections afin d'accélérer le processus de développement en réduisant le temps passé à déchiffrer les problèmes de compilation.

GitLab Duo Chat peut également être utilisé directement depuis le rapport de vulnérabilités pour fournir des explications sur un élément détecté. La fonctionnalité d'explication des vulnérabilités de GitLab Duo représente une avancée significative qui renforce la sécurité des applications pour les équipes de développement. Plutôt que de simplement signaler des problèmes potentiels avec des codes d'erreur peu clairs ou du jargon technique, l'IA décompose la nature de chaque vulnérabilité, son impact potentiel et les étapes de remédiation en termes que les développeurs de tous niveaux peuvent rapidement comprendre.

Cette démocratisation des connaissances en sécurité accélère le processus de remédiation, réduit les allers-retours entre les équipes de sécurité et de développement et aide les organisations à livrer du code plus sécurisé plus rapidement :

Avec GitLab Duo, vous avez également accès à GitLab Duo Agentic Chat, un assistant de développement intelligent pour les applications Rust, qui offre une aide contextuelle tout au long du cycle de développement. Les équipes de développement peuvent tirer parti de son interface conversationnelle pour générer des extraits de code Rust et générer automatiquement des structures de code pour de nouveaux projets Rust avec des configurations Cargo.toml adaptées, entre autres.

Résolution des vulnérabilités avec GitLab Duo

La fonctionnalité de résolution des vulnérabilités de GitLab Duo utilise l'IA pour générer automatiquement des corrections de code spécifiques pour les problèmes de sécurité détectés qui réduisent le temps de remédiation de plusieurs heures à quelques minutes. L'IA analyse les coding patterns vulnérables et propose des correctifs précis adaptés au contexte, au langage de programmation et aux dépendances du projet tout en maintenant la fonctionnalité du code et le style.

Cette automatisation est particulièrement efficace pour les vulnérabilités courantes comme l'injection SQL et le cross-site scripting, car elle permet aux équipes de développement de maintenir leur vélocité tout en améliorant significativement leur posture de sécurité sans perturber le workflow de développement.

Revue de code de GitLab Duo

La revue de code alimentée par l'IA de GitLab Duo améliore le processus de développement grâce à des commentaires intelligents et automatisés dans les merge requests avant toute intervention de réviseurs humains. L'IA analyse les modifications de code pour détecter les bogues potentiels, les vulnérabilités de sécurité, les problèmes de performance et l'adhérence aux normes de codage. De plus, elle fournit des suggestions contextuelles et des explications qui aident les équipes à détecter les problèmes tôt.

En renforçant les revues humaines traditionnelles avec des informations d'IA cohérentes et immédiates, cette fonctionnalité réduit la charge sur les développeurs seniors, accélère le cycle de revue et garantit que les vérifications de qualité de base sont appliquées de manière cohérente à toutes les contributions de code. La qualité du code est ainsi améliorée, et les réviseurs humains peuvent se concentrer sur l'architecture et la logique métier de plus haut niveau.

Ce ne sont là que quelques-unes des fonctionnalités IA qui peuvent être utilisées pour vous permettre de livrer des logiciels Rust plus sécurisés plus rapidement que jamais. Pour en savoir plus sur toutes les fonctionnalités d'IA de GitLab, consultez la page de solution GitLab Duo.

Rust : l'avantage de GitLab

GitLab fournit une plateforme de développement complète en synergie avec l'approche globale de Rust :

Workflow intégré :

• Plateforme unique : code, CI/CD, sécurité et déploiement en un seul endroit
• Optimisation pour Rust : compilations basées sur Docker parfaites pour la chaîne d'outils Rust
• Sécurité d'abord : analyse de sécurité intégrée
• Niveau entreprise : infrastructure évolutive pour les grandes équipes

Avantages de performance :

• Mise en cache efficace : accélération des temps de compilation plus longs de Rust
• Compilations parallèles : optimisation de l'efficacité de GitLab Runner
• Gestion des artefacts : distribution de binaires rationalisée

Expérience développeur :

• Outils familiers : outils Rust standard (Cargo, Clippy, rustfmt)
• Retour visuel : tableaux de bord et rapports complets
• Automatisation : réduction des coûts de déploiement et de test manuels
• IA GitLab Duo : livraison de logiciels plus sécurisés plus rapidement avec l'IA tout au long du cycle du développement logiciel

Les capacités de la plateforme GitLab complètent parfaitement les avantages de Rust pour créer un écosystème où la sécurité, la performance et la productivité des développeurs convergent. Les applications Rust sur GitLab représentent la pointe du développement logiciel et sont alimentées par une plateforme qui comprend et améliore l'expérience de développement Rust.

Pour en savoir plus sur les avantages de GitLab, inscrivez-vous pour un essai gratuit de GitLab Ultimate avec Duo Enterprise.