Guide to DevSecOps

Appearance

Comprehensive Guide to Rust: Installation, Package Management, and CI/CD Deployment ​

Table of Contents ​

Installing Rust ​

Rustup is the official Rust toolchain installer. It installs Rust, Cargo, and additional components.

For Linux and macOS: ​

bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Follow the on-screen instructions. Then, activate the Rust environment:

bash
source $HOME/.cargo/env

For Windows: ​

  1. Download the rustup-init.exe from https://rustup.rs/
  2. Run the installer and follow the instructions
  3. Restart your terminal

Verify Installation ​

After installation, verify Rust is correctly installed:

bash
rustc --version
cargo --version

Updating Rust ​

To update Rust to the latest version:

bash
rustup update

Cargo: Rust Package Manager ​

Cargo is Rust's package manager and build system. It comes pre-installed with Rust via rustup.

Basic Cargo Commands ​

bash
# Create a new Rust project
cargo new my_project

# Build a project
cargo build

# Build with optimizations for release
cargo build --release

# Run the project
cargo run

# Test the project
cargo test

# Check if your project compiles
cargo check

# Update dependencies
cargo update

# Add a dependency
cargo add dependency_name

Building and Compiling Rust Applications ​

Development Builds ​

bash
# Debug build (includes debug symbols)
cargo build

# Check compilation without producing an executable
cargo check

Production Builds ​

bash
# Optimized release build
cargo build --release

Cross-Compilation ​

Install target for cross-compilation:

bash
rustup target add x86_64-unknown-linux-musl

Build for a specific target:

bash
cargo build --target x86_64-unknown-linux-musl --release

Packaging Rust Applications ​

Binary Distribution ​

The simplest way to distribute your application is to share the compiled binary:

bash
# Build the release binary
cargo build --release

# The binary will be in ./target/release/

Cargo Workspaces ​

For multi-crate projects, use Cargo workspaces:

toml
# In root Cargo.toml
[workspace]
members = [
    "app",
    "lib1",
    "lib2",
]

Creating a Rust Library ​

To create a library that others can use:

bash
cargo new --lib my_library

Publish to crates.io:

bash
cargo login
cargo publish

CI/CD Deployment ​

GitHub Actions ​

Create a .github/workflows/rust.yml file:

yaml
name: Rust CI/CD

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Build
      run: cargo build --verbose
    - name: Run tests
      run: cargo test --verbose
    
  release:
    needs: build
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Build release
      run: cargo build --release
    - name: Upload artifacts
      uses: actions/upload-artifact@v3
      with:
        name: release-binary
        path: target/release/your_app_name

GitLab CI ​

Create a .gitlab-ci.yml file:

yaml
stages:
  - build
  - test
  - deploy

build:
  stage: build
  image: rust:latest
  script:
    - cargo build --release
  artifacts:
    paths:
      - target/release/

test:
  stage: test
  image: rust:latest
  script:
    - cargo test

deploy:
  stage: deploy
  image: rust:latest
  script:
    - cargo build --release
  only:
    - main
  artifacts:
    paths:
      - target/release/your_app_name

Jenkins ​

Create a Jenkinsfile:

groovy
pipeline {
    agent {
        docker {
            image 'rust:latest'
        }
    }
    stages {
        stage('Build') {
            steps {
                sh 'cargo build --release'
            }
        }
        stage('Test') {
            steps {
                sh 'cargo test'
            }
        }
        stage('Deploy') {
            when {
                branch 'main'
            }
            steps {
                sh 'cargo build --release'
                archiveArtifacts artifacts: 'target/release/your_app_name', fingerprint: true
            }
        }
    }
}

Azure DevOps ​

Create an azure-pipelines.yml file:

yaml
trigger:
  - main

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: |
    curl https://sh.rustup.rs -sSf | sh -s -- -y
    echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
  displayName: 'Install Rust'

- script: cargo build --release
  displayName: 'Build Release'

- script: cargo test
  displayName: 'Run Tests'

- task: CopyFiles@2
  inputs:
    contents: 'target/release/your_app_name'
    targetFolder: '$(Build.ArtifactStagingDirectory)'
  displayName: 'Copy Artifacts'

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: '$(Build.ArtifactStagingDirectory)'
    artifactName: 'rust-app'
  displayName: 'Publish Artifacts'

Circle CI ​

Create a .circleci/config.yml file:

yaml
version: 2.1
jobs:
  build:
    docker:
      - image: rust:latest
    steps:
      - checkout
      - run:
          name: Build
          command: cargo build --release
      - run:
          name: Test
          command: cargo test
      - store_artifacts:
          path: target/release/your_app_name
          destination: your_app_name

Travis CI ​

Create a .travis.yml file:

yaml
language: rust
rust:
  - stable
  - beta
  - nightly

jobs:
  allow_failures:
    - rust: nightly
  fast_finish: true

script:
  - cargo build --verbose
  - cargo test --verbose

deploy:
  provider: releases
  api_key: $GITHUB_TOKEN
  file: target/release/your_app_name
  skip_cleanup: true
  on:
    tags: true
    rust: stable

Conclusion ​

This guide covered the essential steps for installing Rust, using Cargo for package management, building and packaging Rust applications, and deploying them through various CI/CD systems. As your project grows, you may need to customize these steps to meet specific requirements.

For more information, refer to: