Integration

CI/CD Pipeline Integration

GitHub Actions

yaml

name: OpenCV Build
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Install OpenCV
      run: |
        sudo apt update
        sudo apt install -y libopencv-dev clang libclang-dev
    - name: Install Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
    - name: Build
      run: cargo build --release
    - name: Test
      run: cargo test

GitLab CI

yaml

stages:
  - build
  - test
build:
  stage: build
  image: rust:1.70
  before_script:
    - apt-get update
    - apt-get install -y libopencv-dev clang libclang-dev
  script:
    - cargo build --release
  artifacts:
    paths:
      - target/release/
test:
  stage: test
  script:
    - cargo test

Container Integration Multi-stage Dockerfile

dockerfile

# Builder stage
FROM rust:1.70 as builder
RUN apt-get update && apt-get install -y \
    cmake pkg-config libssl-dev \
    libopencv-dev clang libclang-dev
WORKDIR /app
COPY . .
RUN cargo build --release
# Runtime stage
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y \
    libopencv-core4.5 \
    libopencv-imgproc4.5 \
    && rm -rf /var/lib/apt/lists/*
COPY --from=builder /app/target/release/app /usr/local/bin/
CMD ["app"]

Kubernetes Deployment

yaml

apiVersion: apps/v1 kind: Deployment metadata: name: opencv-app spec: replicas: 3 selector: matchLabels: app: opencv-app template: metadata: labels: app: opencv-app spec: containers:

• name: opencv-app image: opencv-app:latest resources: requests: memory: "512Mi" cpu: "250m" limits: memory: "2Gi" cpu: "1000m" env:
  • name: OPENCV_THREAD_COUNT value: "4" Service Integration

## Web Service Integration

rust

use axum::{extract::Multipart, response::Json, routing::post, Router};
use opencv::{imgcodecs, imgproc, core::Mat};
async fn process_image(mut multipart: Multipart) -> Result<Json<String>, String> {
    while let Some(field) = multipart.next_field().await.unwrap() {
        let data = field.bytes().await.unwrap();
        // Decode image
        let mut img = imgcodecs::imdecode(
            &data.to_vec(),
            imgcodecs::IMREAD_COLOR
        ).map_err(|e| e.to_string())?;
        // Process image
        let mut processed = Mat::default();
        imgproc::gaussian_blur(
            &img,
            &mut processed,
            core::Size::new(15, 15),
            0.0,
            0.0,
            core::BORDER_DEFAULT
        ).map_err(|e| e.to_string())?;
        return Ok(Json("Image processed successfully".to_string()));
    }
    Err("No image provided".to_string())
}
#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/process", post(process_image));
    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}