SBT Repositories

This section provides comprehensive documentation for configuring and using SBT-based repositories with CloudRepo for Scala projects.

Overview

SBT (Scala Build Tool) is the de facto build tool for Scala projects, providing powerful dependency management, incremental compilation, and cross-compilation capabilities. SBT uses a Scala-based DSL and integrates seamlessly with both Maven and Ivy repository formats.

SBT and Repository Formats

SBT can work with both Maven and Ivy repository formats:

Maven Repositories: The most common format, compatible with Maven Central and most artifact repositories
Ivy Repositories: Legacy format still used by some Scala libraries, particularly older ones

CloudRepo supports Maven repository format, which is fully compatible with SBT and covers the vast majority of use cases.

Why Private SBT Repositories?

Scala development teams need private repositories to:

Protect Proprietary Code: Secure internal Scala libraries and domain-specific languages (DSLs)
Manage Cross-Compilation: Store artifacts compiled for multiple Scala versions (2.12, 2.13, 3.x)
Distribute SBT Plugins: Share custom SBT plugins within your organization
Control Dependencies: Ensure consistent dependency versions across microservices
Support Multiple Platforms: Manage artifacts for JVM, Scala.js, and Scala Native
Cache Dependencies: Improve build times by caching commonly used libraries

CloudRepo provides fully managed, cloud-based repositories that eliminate infrastructure overhead while providing enterprise-grade security and no egress fees.

Prerequisites

Before configuring SBT with CloudRepo, ensure you have:

Created a Maven Repository: Set up a Maven-type repository in the CloudRepo Admin Portal
Created a Repository User: Configure a dedicated user for repository access
Installed SBT: Version 1.0 or higher recommended

If you haven’t completed the repository setup, please refer to:

Important

Admin users cannot directly access repositories for security reasons. Always create dedicated repository users for artifact access.

Note

CloudRepo repositories use the following URL format: https://[organization-id].mycloudrepo.io/repositories/[repository-id]

Basic Configuration

SBT configuration is typically done in build.sbt at the project root. We’ll cover both consuming and publishing artifacts.

Setting Up Resolvers

Add CloudRepo as a resolver to fetch dependencies:

build.sbt - Basic Resolver Configuration

// CloudRepo resolver for private dependencies
resolvers += "CloudRepo" at "https://your-org.mycloudrepo.io/repositories/your-repo"

// Include standard resolvers
resolvers ++= Seq(
  Resolver.mavenCentral,
  Resolver.sonatypeRepo("releases"),
  Resolver.sonatypeRepo("snapshots")
)

// Dependencies from CloudRepo
libraryDependencies ++= Seq(
  "com.yourcompany" %% "your-scala-library" % "1.0.0",
  "com.yourcompany" % "your-java-library" % "2.1.0"
)

Note

Use %% for Scala libraries (adds Scala version suffix) and % for Java libraries.

Authentication Setup

SBT supports multiple authentication methods. Choose the one that best fits your workflow:

Method 1: Credentials File (Recommended)

Create a credentials file at ~/.sbt/.credentials:

~/.sbt/.credentials

realm=CloudRepo
host=your-org.mycloudrepo.io
user=your-username
password=your-password

Then reference it in build.sbt:

build.sbt - Credentials File

credentials += Credentials(Path.userHome / ".sbt" / ".credentials")

Method 2: Environment Variables

Use environment variables for CI/CD environments:

build.sbt - Environment Variables

credentials += Credentials(
  "CloudRepo",
  "your-org.mycloudrepo.io",
  sys.env.getOrElse("CLOUDREPO_USERNAME", ""),
  sys.env.getOrElse("CLOUDREPO_PASSWORD", "")
)

Method 3: Inline Credentials (Not Recommended)

For testing only - never commit credentials to version control:

build.sbt - Inline Credentials (Testing Only)

credentials += Credentials(
  "CloudRepo",
  "your-org.mycloudrepo.io",
  "username",
  "password"
)

Publishing Configuration

Configure SBT to publish artifacts to CloudRepo:

Basic Publishing Setup

build.sbt - Publishing Configuration

// Organization and artifact settings
organization := "com.yourcompany"
name := "your-scala-library"
version := "1.0.0"

// Scala version and cross-compilation
scalaVersion := "2.13.12"
crossScalaVersions := Seq("2.12.18", "2.13.12", "3.3.1")

// Publishing settings
publishTo := {
  val cloudRepo = "https://your-org.mycloudrepo.io/repositories/"
  if (isSnapshot.value)
    Some("snapshots" at cloudRepo + "snapshots")
  else
    Some("releases" at cloudRepo + "releases")
}

// Include sources and javadocs
publishArtifact in (Compile, packageSrc) := true
publishArtifact in (Compile, packageDoc) := true

// POM customization
pomIncludeRepository := { _ => false }
pomExtra := (
  <url>https://github.com/yourcompany/your-library</url>
  <licenses>
    <license>
      <name>Apache 2.0</name>
      <url>http://www.apache.org/licenses/LICENSE-2.0</url>
    </license>
  </licenses>
  <scm>
    <connection>scm:git:github.com/yourcompany/your-library.git</connection>
    <developerConnection>scm:git:git@github.com:yourcompany/your-library.git</developerConnection>
    <url>github.com/yourcompany/your-library</url>
  </scm>
  <developers>
    <developer>
      <id>johndoe</id>
      <name>John Doe</name>
      <email>john@yourcompany.com</email>
    </developer>
  </developers>
)

Publishing Commands

Once configured, use these SBT commands:

Publishing Commands

# Publish to CloudRepo
sbt publish

# Publish locally for testing
sbt publishLocal

# Cross-publish for all Scala versions
sbt +publish

# Publish signed artifacts (if GPG configured)
sbt publishSigned

# Clean, compile, test, and publish
sbt clean compile test publish

Advanced Publishing Features

SNAPSHOT vs Release Versions

SBT automatically detects SNAPSHOT versions:

build.sbt - Version-based Publishing

version := "1.0.0-SNAPSHOT"  // Will publish to snapshots repository

publishTo := {
  val baseUrl = "https://your-org.mycloudrepo.io/repositories/"
  if (version.value.endsWith("SNAPSHOT"))
    Some("CloudRepo Snapshots" at baseUrl + "snapshots")
  else
    Some("CloudRepo Releases" at baseUrl + "releases")
}

// Overwrite snapshots (useful for CI)
publishConfiguration := publishConfiguration.value.withOverwrite(true)
publishLocalConfiguration := publishLocalConfiguration.value.withOverwrite(true)

Cross-Building for Multiple Scala Versions

build.sbt - Cross-Building Configuration

scalaVersion := "2.13.12"
crossScalaVersions := Seq("2.12.18", "2.13.12", "3.3.1")

// Version-specific dependencies
libraryDependencies ++= {
  CrossVersion.partialVersion(scalaVersion.value) match {
    case Some((2, 12)) =>
      Seq("org.scala-lang.modules" %% "scala-collection-compat" % "2.11.0")
    case Some((2, 13)) =>
      Seq.empty
    case Some((3, _)) =>
      Seq.empty
    case _ =>
      Seq.empty
  }
}

// Publish all cross-built versions
// Run: sbt +publish

Consuming Dependencies

Configuring Multiple Repositories

build.sbt - Multiple Repository Configuration

// Define repository URLs
val cloudRepoReleases = "CloudRepo Releases" at
  "https://your-org.mycloudrepo.io/repositories/releases"
val cloudRepoSnapshots = "CloudRepo Snapshots" at
  "https://your-org.mycloudrepo.io/repositories/snapshots"

// Configure resolvers with priority order
resolvers ++= Seq(
  cloudRepoReleases,
  cloudRepoSnapshots,
  Resolver.mavenCentral,
  Resolver.sonatypeRepo("releases"),
  "Typesafe Repository" at "https://repo.typesafe.com/typesafe/releases/",
  Resolver.jcenterRepo
)

// Credentials for private repositories
credentials += Credentials(Path.userHome / ".sbt" / ".credentials")

// Dependencies
libraryDependencies ++= Seq(
  "com.yourcompany" %% "core-library" % "2.1.0",
  "com.yourcompany" %% "utils" % "1.3.2",
  "com.typesafe.akka" %% "akka-actor" % "2.8.5",
  "org.scalatest" %% "scalatest" % "3.2.17" % Test
)

Resolver Chains and Patterns

Configure custom resolver patterns for non-standard layouts:

build.sbt - Custom Resolver Patterns

// Maven-style resolver (default)
resolvers += "CloudRepo Maven" at
  "https://your-org.mycloudrepo.io/repositories/maven"

// Ivy-style resolver with custom pattern
resolvers += Resolver.url(
  "CloudRepo Ivy",
  url("https://your-org.mycloudrepo.io/repositories/ivy")
)(Resolver.ivyStylePatterns)

// Custom artifact pattern
resolvers += {
  val patterns = Patterns()
    .withIsMavenCompatible(true)
    .withArtifactPatterns(Vector(
      "[organisation]/[module]/[revision]/[artifact]-[revision](-[classifier]).[ext]"
    ))
    .withIvyPatterns(Vector(
      "[organisation]/[module]/[revision]/ivy.xml"
    ))

  Resolver.url("CloudRepo Custom",
    url("https://your-org.mycloudrepo.io/repositories/custom"))(patterns)
}

Cache Management

Control how SBT caches dependencies:

build.sbt - Cache Configuration

// Force update of snapshots
updateOptions := updateOptions.value.withLatestSnapshots(true)

// Cache resolution for faster builds
updateOptions := updateOptions.value.withCachedResolution(true)

// Custom cache location
dependencyCacheDirectory := baseDirectory.value / ".cache"

// Clean cache task
val cleanCache = taskKey[Unit]("Clean dependency cache")
cleanCache := {
  import sbt.io.IO
  IO.delete(dependencyCacheDirectory.value)
}

Multi-Project Builds

SBT excels at managing multi-module projects:

Project Structure

Multi-Project Structure

my-application/
├── build.sbt
├── project/
│   ├── build.properties
│   ├── plugins.sbt
│   └── Dependencies.scala
├── common/
│   └── src/
├── core/
│   └── src/
├── api/
│   └── src/
└── web/
    └── src/

Root Build Configuration

build.sbt - Multi-Project Configuration

import Dependencies._

ThisBuild / organization := "com.yourcompany"
ThisBuild / scalaVersion := "2.13.12"
ThisBuild / version := "1.0.0-SNAPSHOT"

// CloudRepo configuration for all projects
ThisBuild / resolvers += "CloudRepo" at
  "https://your-org.mycloudrepo.io/repositories/your-repo"

ThisBuild / publishTo := {
  val cloudRepo = "https://your-org.mycloudrepo.io/repositories/"
  if (isSnapshot.value)
    Some("snapshots" at cloudRepo + "snapshots")
  else
    Some("releases" at cloudRepo + "releases")
}

ThisBuild / credentials += Credentials(Path.userHome / ".sbt" / ".credentials")

// Root project (doesn't publish)
lazy val root = (project in file("."))
  .settings(
    name := "my-application",
    publish / skip := true
  )
  .aggregate(common, core, api, web)

// Common utilities module
lazy val common = (project in file("common"))
  .settings(
    name := "common",
    libraryDependencies ++= commonDependencies
  )

// Core business logic
lazy val core = (project in file("core"))
  .settings(
    name := "core",
    libraryDependencies ++= coreDependencies
  )
  .dependsOn(common)

// API module
lazy val api = (project in file("api"))
  .settings(
    name := "api",
    libraryDependencies ++= apiDependencies
  )
  .dependsOn(core)

// Web application
lazy val web = (project in file("web"))
  .settings(
    name := "web",
    libraryDependencies ++= webDependencies,
    // Don't publish the web module
    publish / skip := true
  )
  .dependsOn(api)

Dependencies Object

project/Dependencies.scala

import sbt._

object Dependencies {
  // Versions
  val akkaVersion = "2.8.5"
  val circeVersion = "0.14.6"
  val http4sVersion = "0.23.23"
  val scalaTestVersion = "3.2.17"

  // Common dependencies
  val commonDependencies = Seq(
    "org.typelevel" %% "cats-core" % "2.10.0",
    "com.typesafe.scala-logging" %% "scala-logging" % "3.9.5",
    "ch.qos.logback" % "logback-classic" % "1.4.11",
    "org.scalatest" %% "scalatest" % scalaTestVersion % Test
  )

  // Core dependencies
  val coreDependencies = Seq(
    "com.typesafe.akka" %% "akka-actor-typed" % akkaVersion,
    "com.typesafe.akka" %% "akka-stream" % akkaVersion,
    "io.circe" %% "circe-core" % circeVersion,
    "io.circe" %% "circe-generic" % circeVersion,
    "io.circe" %% "circe-parser" % circeVersion
  )

  // API dependencies
  val apiDependencies = Seq(
    "org.http4s" %% "http4s-ember-server" % http4sVersion,
    "org.http4s" %% "http4s-circe" % http4sVersion,
    "org.http4s" %% "http4s-dsl" % http4sVersion
  )

  // Web dependencies
  val webDependencies = Seq(
    "org.http4s" %% "http4s-ember-client" % http4sVersion,
    "org.http4s" %% "http4s-scala-xml" % http4sVersion
  )
}

Advanced SBT Features

Cross-Platform Building

Build for JVM, Scala.js, and Scala Native:

build.sbt - Cross-Platform Configuration

import sbtcrossproject.CrossPlugin.autoImport.{crossProject, CrossType}

lazy val sharedSettings = Seq(
  organization := "com.yourcompany",
  version := "1.0.0",
  scalaVersion := "2.13.12"
)

lazy val myLibrary = crossProject(JVMPlatform, JSPlatform, NativePlatform)
  .crossType(CrossType.Pure)
  .in(file("my-library"))
  .settings(sharedSettings)
  .settings(
    name := "my-cross-platform-library",
    libraryDependencies ++= Seq(
      "org.scalatest" %%% "scalatest" % "3.2.17" % Test
    )
  )
  .jvmSettings(
    // JVM-specific settings
    libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.8.5"
  )
  .jsSettings(
    // Scala.js-specific settings
    scalaJSUseMainModuleInitializer := true,
    libraryDependencies += "org.scala-js" %%% "scalajs-dom" % "2.8.0"
  )
  .nativeSettings(
    // Scala Native-specific settings
    nativeLinkStubs := true
  )

lazy val myLibraryJVM = myLibrary.jvm
lazy val myLibraryJS = myLibrary.js
lazy val myLibraryNative = myLibrary.native

SBT Plugin Distribution

Create and distribute custom SBT plugins via CloudRepo:

project/plugins.sbt - Custom Plugin

// Plugin project build.sbt
sbtPlugin := true
organization := "com.yourcompany"
name := "sbt-custom-plugin"
version := "0.1.0"

publishTo := Some("CloudRepo" at
  "https://your-org.mycloudrepo.io/repositories/sbt-plugins")

// Add plugin dependencies
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.1.5")

To use the published plugin in other projects:

project/plugins.sbt - Using Custom Plugin

resolvers += "CloudRepo Plugins" at
  "https://your-org.mycloudrepo.io/repositories/sbt-plugins"

addSbtPlugin("com.yourcompany" % "sbt-custom-plugin" % "0.1.0")

Assembly Plugin for Fat JARs

Create executable fat JARs with all dependencies:

build.sbt - Assembly Configuration

import sbtassembly.AssemblyPlugin.autoImport._

// Assembly settings
assembly / assemblyJarName := s"${name.value}-${version.value}-fat.jar"

assembly / mainClass := Some("com.yourcompany.Main")

// Merge strategy for duplicate files
assembly / assemblyMergeStrategy := {
  case "META-INF/services/org.apache.spark.sql.sources.DataSourceRegister" =>
    MergeStrategy.concat
  case PathList("META-INF", xs @ _*) => MergeStrategy.discard
  case "reference.conf" => MergeStrategy.concat
  case x => MergeStrategy.defaultMergeStrategy(x)
}

// Exclude Scala library from fat JAR (if provided at runtime)
assembly / assemblyOption := (assembly / assemblyOption).value
  .withIncludeScala(false)

// Publish fat JAR to CloudRepo
addArtifact(assembly / assemblyArtifact)

publishTo := Some("CloudRepo" at
  "https://your-org.mycloudrepo.io/repositories/releases")

Custom Tasks and Commands

build.sbt - Custom Tasks

// Custom deployment task
val deploy = taskKey[Unit]("Deploy to CloudRepo and notify")

deploy := {
  val log = streams.value.log

  // Run tests
  (Test / test).value
  log.info("Tests passed")

  // Publish artifacts
  publish.value
  log.info(s"Published ${name.value} ${version.value} to CloudRepo")

  // Custom notification logic
  val webhook = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
  import scala.sys.process._
  val message = s"""{"text":"Deployed ${name.value} ${version.value}"}"""
  s"""curl -X POST -H 'Content-Type: application/json' -d '$message' $webhook""".!
}

// Custom command with arguments
commands += Command.args("release", "<version>") { (state, args) =>
  val version = args.headOption.getOrElse("1.0.0")
  s"""set version := "$version"""" ::
  "clean" ::
  "compile" ::
  "test" ::
  "publish" ::
  state
}

Coursier for Faster Resolution

Use Coursier for faster dependency resolution:

project/plugins.sbt - Coursier Setup

1addSbtCoursier

build.sbt - Coursier Configuration

// Coursier cache configuration
csrCacheDirectory := Some(baseDirectory.value / ".coursier-cache")

// Parallel downloads
coursierParallelDownloads := 8

// Custom repository with Coursier
resolvers += MavenRepository(
  "CloudRepo",
  "https://your-org.mycloudrepo.io/repositories/releases",
  credentials = Credentials(Path.userHome / ".sbt" / ".credentials")
)

CI/CD Integration

GitHub Actions

.github/workflows/scala-ci.yml

name: Scala CI

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

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        scala: [ '2.12.18', '2.13.12', '3.3.1' ]

    steps:
    - uses: actions/checkout@v3

    - name: Setup JDK
      uses: actions/setup-java@v3
      with:
        distribution: 'temurin'
        java-version: '11'

    - name: Setup Scala
      uses: olafurpg/setup-scala@v13
      with:
        java-version: '11'

    - name: Cache SBT
      uses: actions/cache@v3
      with:
        path: |
          ~/.sbt
          ~/.ivy2/cache
          ~/.coursier
        key: ${{ runner.os }}-sbt-${{ matrix.scala }}-${{ hashFiles('**/build.sbt') }}

    - name: Configure CloudRepo credentials
      run: |
        mkdir -p ~/.sbt
        echo "realm=CloudRepo" > ~/.sbt/.credentials
        echo "host=${{ secrets.CLOUDREPO_HOST }}" >> ~/.sbt/.credentials
        echo "user=${{ secrets.CLOUDREPO_USERNAME }}" >> ~/.sbt/.credentials
        echo "password=${{ secrets.CLOUDREPO_PASSWORD }}" >> ~/.sbt/.credentials

    - name: Run tests
      run: sbt ++${{ matrix.scala }} clean coverage test coverageReport

    - name: Publish snapshot
      if: github.ref == 'refs/heads/develop'
      run: sbt ++${{ matrix.scala }} publish

    - name: Publish release
      if: github.ref == 'refs/heads/main'
      run: |
        VERSION=$(git describe --tags --abbrev=0)
        sbt ++${{ matrix.scala }} 'set version := "'$VERSION'"' publish

GitLab CI

.gitlab-ci.yml

image: hseeberger/scala-sbt:11.0.15_1.7.1_2.13.12

variables:
  SBT_OPTS: "-Dsbt.global.base=sbt-cache/.sbtboot -Dsbt.boot.directory=sbt-cache/.boot -Dsbt.ivy.home=sbt-cache/.ivy"
  CLOUDREPO_HOST: "your-org.mycloudrepo.io"

cache:
  key: "$CI_PROJECT_ID"
  untracked: true
  paths:
    - sbt-cache/

before_script:
  - mkdir -p ~/.sbt
  - |
    cat > ~/.sbt/.credentials << EOF
    realm=CloudRepo
    host=$CLOUDREPO_HOST
    user=$CLOUDREPO_USERNAME
    password=$CLOUDREPO_PASSWORD
    EOF

stages:
  - test
  - publish

test:
  stage: test
  script:
    - sbt clean coverage test coverageReport
  artifacts:
    reports:
      junit:
        - target/test-reports/*.xml
    paths:
      - target/scala-*/scoverage-report/

publish-snapshot:
  stage: publish
  script:
    - sbt publish
  only:
    - develop

publish-release:
  stage: publish
  script:
    - VERSION=$(git describe --tags --abbrev=0)
    - sbt "set version := \"$VERSION\"" publish
  only:
    - tags

Jenkins Pipeline

Jenkinsfile

pipeline {
    agent {
        docker {
            image 'hseeberger/scala-sbt:11.0.15_1.7.1_2.13.12'
            args '-v /var/run/docker.sock:/var/run/docker.sock'
        }
    }

    environment {
        CLOUDREPO_CREDS = credentials('cloudrepo-credentials')
        SBT_OPTS = '-Xmx2G -XX:+UseG1GC'
    }

    stages {
        stage('Setup') {
            steps {
                sh '''
                    mkdir -p ~/.sbt
                    cat > ~/.sbt/.credentials << EOF
realm=CloudRepo
host=your-org.mycloudrepo.io
user=$CLOUDREPO_CREDS_USR
password=$CLOUDREPO_CREDS_PSW
EOF
                '''
            }
        }

        stage('Compile') {
            steps {
                sh 'sbt clean compile'
            }
        }

        stage('Test') {
            parallel {
                stage('Unit Tests') {
                    steps {
                        sh 'sbt test'
                    }
                }
                stage('Integration Tests') {
                    steps {
                        sh 'sbt it:test'
                    }
                }
            }
        }

        stage('Package') {
            steps {
                sh 'sbt package assembly'
            }
        }

        stage('Publish') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                    tag pattern: "v\\d+\\.\\d+\\.\\d+", comparator: "REGEXP"
                }
            }
            steps {
                script {
                    if (env.TAG_NAME) {
                        sh "sbt 'set version := \"${env.TAG_NAME.substring(1)}\"' publish"
                    } else {
                        sh 'sbt publish'
                    }
                }
            }
        }
    }

    post {
        always {
            junit '**/target/test-reports/*.xml'
            archiveArtifacts artifacts: '**/target/scala-*/*.jar', fingerprint: true
        }
        success {
            echo 'Pipeline successful!'
        }
        failure {
            emailext(
                subject: "Build Failed: ${env.JOB_NAME} - ${env.BUILD_NUMBER}",
                body: "Check console output at ${env.BUILD_URL}",
                to: 'team@yourcompany.com'
            )
        }
    }
}

Legacy SBT Support

For projects using SBT 0.13.x (legacy), some syntax differs:

build.sbt - SBT 0.13.x Syntax

// SBT 0.13.x style
organization := "com.yourcompany"
name := "legacy-project"
version := "1.0.0"
scalaVersion := "2.11.12"

// Resolver configuration (0.13.x)
resolvers += "CloudRepo" at "https://your-org.mycloudrepo.io/repositories/releases"

// Publishing (0.13.x)
publishTo <<= version { v: String =>
  val cloudRepo = "https://your-org.mycloudrepo.io/repositories/"
  if (v.trim.endsWith("SNAPSHOT"))
    Some("snapshots" at cloudRepo + "snapshots")
  else
    Some("releases" at cloudRepo + "releases")
}

// Credentials (0.13.x)
credentials += Credentials(Path.userHome / ".ivy2" / ".credentials")

// Dependencies (0.13.x)
libraryDependencies ++= Seq(
  "com.yourcompany" %% "core" % "1.0.0",
  "org.scalatest" %% "scalatest" % "2.2.6" % "test"
)

Troubleshooting

Common Issues and Solutions

Authentication Failures

Problem: 401 Unauthorized errors when resolving or publishing.

Solutions:

Verify credentials are correct:

curl -u username:password https://your-org.mycloudrepo.io/repositories/releases/

Check credentials file format and location:

cat ~/.sbt/.credentials
# Should show realm, host, user, password on separate lines

Ensure realm matches exactly:

credentials += Credentials("CloudRepo", "your-org.mycloudrepo.io", "user", "pass")

Dependency Resolution Issues

Problem: SBT cannot find dependencies in CloudRepo.

Solutions:

Check resolver URL format:

// Correct
resolvers += "CloudRepo" at "https://your-org.mycloudrepo.io/repositories/releases"

// Incorrect (missing /repositories/)
resolvers += "CloudRepo" at "https://your-org.mycloudrepo.io/releases"

Verify artifact coordinates:

# List repository contents
curl -u username:password https://your-org.mycloudrepo.io/repositories/releases/com/yourcompany/

Clear caches:

rm -rf ~/.ivy2/cache/com.yourcompany
rm -rf ~/.coursier/cache
sbt clean update

Cross-Compilation Issues

Problem: Published artifacts missing for some Scala versions.

Solution:

# Ensure all versions are published
sbt +publish  # Note the + prefix

# Or explicitly for each version
sbt ++2.12.18 publish
sbt ++2.13.12 publish
sbt ++3.3.1 publish

Snapshot Overwriting

Problem: Snapshots not updating despite new publishes.

Solution:

// Force snapshot updates
updateOptions := updateOptions.value.withLatestSnapshots(true)

// For publishing, allow overwrites
publishConfiguration := publishConfiguration.value.withOverwrite(true)

Build Performance

Problem: Slow dependency resolution.

Solutions:

Enable Coursier for faster resolution:

// In project/plugins.sbt
addSbtCoursier

Use cached resolution:

updateOptions := updateOptions.value.withCachedResolution(true)

Parallel downloads:

concurrent.restrictions in Global := Seq(
  Tags.limit(Tags.Test, 1),
  Tags.limitAll(15)
)

Best Practices

Version Management
- Use semantic versioning (MAJOR.MINOR.PATCH)
- Tag releases in Git to match published versions
- Use SNAPSHOT suffix for development versions
Security
- Never commit credentials to version control
- Use environment variables in CI/CD
- Rotate credentials regularly
- Use read-only credentials where possible
Repository Organization
- Separate releases and snapshots repositories
- Use descriptive artifact names
- Include sources and documentation
- Clean up old snapshots periodically
Build Optimization
- Cache dependencies in CI/CD
- Use Coursier for faster resolution
- Parallelize test execution
- Minimize resolver chain length
Documentation
- Document custom SBT tasks
- Include README with setup instructions
- Document cross-compilation requirements
- Maintain CHANGELOG for releases

Summary

SBT with CloudRepo provides a powerful, scalable solution for managing Scala artifacts. Key benefits include:

Seamless Integration: Native support for Maven repository format
Cross-Compilation: Easy management of multiple Scala versions
No Egress Fees: Cost-effective artifact distribution
Enterprise Security: Fine-grained access controls
Multi-Platform Support: JVM, Scala.js, and Scala Native

With proper configuration, teams can efficiently share Scala libraries, manage dependencies, and maintain consistent builds across development, staging, and production environments.

Additional Resources

For additional help or questions, please contact CloudRepo support. We typically respond within a few business hours and are happy to help with any SBT configuration challenges.