Complete Migration Guide: Sonatype Nexus to CloudRepo

Migrating from Sonatype Nexus Repository to CloudRepo trades self-hosted infrastructure and operations overhead for flat pricing with every feature on every plan and no per-seat billing. This comprehensive guide walks you through every step of a successful migration, from initial planning to production cutover.

Why Teams Are Migrating from Nexus

Organizations worldwide are moving from self-hosted Nexus installations to CloudRepo for compelling reasons. Whether you’re hosting Maven repositories, Python packages, or npm modules, here’s why teams are making the switch:

Dramatic Cost Reduction

• Flat pricing with every feature on every plan in place of Nexus infrastructure and licensing
• No hidden infrastructure costs - eliminate servers, storage, networking, and maintenance
• Predictable monthly pricing - no surprise bills for storage or bandwidth
• No expensive support contracts - support included with all CloudRepo plans

Simplified Management

• Zero infrastructure overhead - no servers to patch, upgrade, or monitor
• No servers to scale - we run and size the service for you
• Built-in high availability - enterprise redundancy without the complexity
• No Nexus configuration to run - sign up, create repositories, start pushing

Superior Developer Experience

• Faster artifact downloads - managed cloud infrastructure vs single Nexus server
• No VPN required - secure cloud access from anywhere
• Better CI/CD integration - native support for modern pipelines

Migration Overview

Migrating from Nexus to CloudRepo is straightforward and can be completed with zero downtime. Here’s what the process involves:

What Gets Migrated

• Core repository types: Maven, Gradle, Python (PyPI), npm, Docker/OCI, and Raw/HTTP
• Artifacts and metadata: Complete preservation of your artifact history
• Users and permissions: Map Nexus roles to CloudRepo’s permission model
• Repository configurations: Hosted and group repositories, plus proxy repositories for Maven and Python
• Build tool configurations: Update Maven, Gradle, pip, npm settings

Timeline Expectations

Most migrations follow this timeline:

• Small teams (< 10GB): 1-2 days
• Medium teams (10-100GB): 3-5 days
• Large teams (100GB-1TB): 1-2 weeks
• Enterprise (> 1TB): 2-4 weeks with CloudRepo migration assistance

Zero-Downtime Migration Strategy

Our proven approach ensures continuous service during migration:

1. Dual-running period: Keep Nexus operational while setting up CloudRepo
2. Incremental sync: Migrate artifacts in batches without disrupting builds
3. Gradual cutover: Move teams progressively to minimize risk
4. Rollback capability: Maintain ability to revert if needed

Pre-Migration Checklist

Before starting your migration, complete this preparation checklist:

1. Audit Current Nexus Usage

# Check total storage usage
du -sh /path/to/nexus-data/blobs

# Count total artifacts
find /path/to/nexus-data/blobs -type f | wc -l

# List all repositories
curl -u admin:password https://nexus.example.com/service/rest/v1/repositories

2. Identify Active Repositories

Document which repositories are actively used:

• Production repositories vs development/test
• Public proxy repositories being used
• Custom repository groups
• Repository cleanup policies

3. Document Access Patterns

• List all users and service accounts
• Map current permissions and roles
• Identify CI/CD systems accessing Nexus
• Document any custom integrations or scripts

4. Review Security Requirements

• SSL/TLS certificate requirements
• IP whitelisting needs (CloudRepo can block by IP range. Contact support to have one configured; it is not a self-service portal feature)
• Compliance requirements (SOC 2, HIPAA, etc.)
• Audit logging requirements

Step-by-Step Migration Process

Step 1: Create CloudRepo Account and Repositories

Start by setting up your CloudRepo environment:

# 1. Sign up for CloudRepo 14-day free trial at https://cloudrepo.io/signup

# 2. Create repositories matching your Nexus structure
# Example: Creating a Maven repository via CloudRepo API
curl -X POST https://api.cloudrepo.io/repositories \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "maven-releases",
    "type": "maven2",
    "storage": "hosted"
  }'

Step 2: Configure Authentication

Set up authentication for your teams:

<!-- Maven settings.xml -->
<settings>
  <servers>
    <server>
      <id>cloudrepo-releases</id>
      <username>your-username</username>
      <password>your-token</password>
    </server>
    <server>
      <id>cloudrepo-snapshots</id>
      <username>your-username</username>
      <password>your-token</password>
    </server>
  </servers>
</settings>

Step 3: Migrate Maven/Gradle Artifacts

Use our migration script for bulk transfers:

#!/bin/bash
# CloudRepo Maven Migration Script

NEXUS_URL="https://nexus.example.com"
CLOUDREPO_URL="https://YOUR_ORG.mycloudrepo.io"
NEXUS_REPO="maven-releases"
CLOUDREPO_REPO="maven-releases"

# Download artifacts from Nexus
mvn dependency:get \
  -DremoteRepositories=$NEXUS_URL/repository/$NEXUS_REPO \
  -Dartifact=GROUP:ARTIFACT:VERSION

# Upload to CloudRepo
mvn deploy:deploy-file \
  -DrepositoryId=cloudrepo-releases \
  -Durl=$CLOUDREPO_URL/repository/$CLOUDREPO_REPO \
  -DgroupId=GROUP \
  -DartifactId=ARTIFACT \
  -Dversion=VERSION \
  -Dfile=./path/to/artifact.jar

For large-scale migrations, use our bulk migration tool:

# bulk_migrate.py - CloudRepo Bulk Migration Tool
import requests
import os
from concurrent.futures import ThreadPoolExecutor

def migrate_artifact(artifact_path):
    """Migrate a single artifact from Nexus to CloudRepo"""
    # Download from Nexus
    nexus_url = f"{NEXUS_BASE}/repository/{artifact_path}"
    response = requests.get(nexus_url, auth=(NEXUS_USER, NEXUS_PASS))

    # Upload to CloudRepo
    cloudrepo_url = f"{CLOUDREPO_BASE}/repository/{artifact_path}"
    headers = {"Authorization": f"Bearer {CLOUDREPO_TOKEN}"}
    upload_response = requests.put(
        cloudrepo_url,
        data=response.content,
        headers=headers
    )

    return upload_response.status_code == 201

# Parallel migration for speed
with ThreadPoolExecutor(max_workers=10) as executor:
    results = executor.map(migrate_artifact, artifact_list)

Step 4: Migrate Python Packages

For Python packages, install your private packages from CloudRepo alone, in a pip step of their own. Do not give pip CloudRepo and PyPI together: pip reads the pair as one index, so a package someone publishes on PyPI under your private package’s name can be installed instead of yours.

# Public packages, from PyPI
pip install -r requirements.txt

# Private packages, from CloudRepo alone
pip install -r requirements-private.txt

--index-url https://${CLOUDREPO_USERNAME}:${CLOUDREPO_API_TOKEN}@YOUR_ORG.mycloudrepo.io/repositories/pypi/simple/
acme-shared-lib==1.2.0

pip fills in the two variables from the environment, so the file holds no credential. Nothing in requirements.txt may depend on a private package, your own project included; install your project last with pip install --no-deps -e ..

Migrate existing packages:

# Download from Nexus
pip download --index-url https://nexus.example.com/repository/pypi/simple/ \
  --dest ./packages PACKAGE_NAME

# Upload to CloudRepo
twine upload --repository-url https://YOUR_ORG.mycloudrepo.io/repositories/pypi/ \
  ./packages/*

Step 5: Update CI/CD Pipelines

Update your CI/CD configurations to point to CloudRepo:

Jenkins Pipeline:

// Jenkinsfile - Before (Nexus)
pipeline {
    environment {
        MAVEN_OPTS = '-Dmaven.repo.remote=https://nexus.example.com/repository/maven-public'
    }
}

// Jenkinsfile - After (CloudRepo)
pipeline {
    environment {
        MAVEN_OPTS = '-Dmaven.repo.remote=https://YOUR_ORG.mycloudrepo.io/repositories/maven-public'
    }
}

GitHub Actions:

# .github/workflows/build.yml - Before (Nexus)
- name: Configure Maven
  run: |
    echo "<settings>...</settings>" > ~/.m2/settings.xml

# .github/workflows/build.yml - After (CloudRepo)
- name: Configure Maven for CloudRepo
  run: |
    cat > ~/.m2/settings.xml << EOF
    <settings>
      <servers>
        <server>
          <id>cloudrepo</id>
          <username>${{ secrets.CLOUDREPO_USERNAME }}</username>
          <password>${{ secrets.CLOUDREPO_TOKEN }}</password>
        </server>
      </servers>
      <mirrors>
        <mirror>
          <id>cloudrepo</id>
          <url>https://YOUR_ORG.mycloudrepo.io/repositories/maven-public</url>
          <mirrorOf>*</mirrorOf>
        </mirror>
      </mirrors>
    </settings>
    EOF

GitLab CI:

# .gitlab-ci.yml - After (CloudRepo)
variables:
  MAVEN_OPTS: '-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository'
  MAVEN_SETTINGS_PATH: '$CI_PROJECT_DIR/.m2/settings.xml'

before_script:
  - echo "$CLOUDREPO_SETTINGS_XML" > $MAVEN_SETTINGS_PATH

Step 6: Migrate Users and Permissions

Map Nexus roles to CloudRepo permissions:

Create each person in the admin portal: click Users in the sidebar, then Create User, then open the new user’s settings to set Read Only access or administrator permissions. For CI, create a repository token under Repository Tokens, limited to the repositories the job uses and to read or write.

Step 7: Test and Validate

Comprehensive testing checklist:

# 1. Test artifact download
mvn dependency:get -DgroupId=com.example -DartifactId=test -Dversion=1.0.0

# 2. Test artifact upload
mvn deploy:deploy-file -Dfile=test.jar -DgroupId=com.example \
  -DartifactId=test -Dversion=1.0.1 -Dpackaging=jar \
  -DrepositoryId=cloudrepo -Durl=https://YOUR_ORG.mycloudrepo.io/repositories/maven-releases

# 3. Verify CI/CD pipeline
git push --force-with-lease  # Trigger your CI/CD pipeline

# 4. Load test (optional)
ab -n 1000 -c 10 https://YOUR_ORG.mycloudrepo.io/repositories/maven-public/com/example/test/1.0.0/test-1.0.0.jar

Step 8: Cut Over Production

Execute the production cutover:

1. Final sync: Run one last migration sync
2. Update DNS (if using custom domain): Point repository.yourdomain.com to CloudRepo
3. Switch configurations: Deploy updated settings to all systems
4. Monitor closely: Watch logs and metrics for 24-48 hours
5. Decommission Nexus: After validation period, safely shut down Nexus

Repository Configuration Mapping

Understanding how Nexus concepts map to CloudRepo:

Nexus Maven Proxy → CloudRepo Proxy Repositories

<!-- Nexus proxy configuration -->
<proxy>
  <id>central</id>
  <url>https://repo.maven.apache.org/maven2</url>
</proxy>

<!-- CloudRepo equivalent -->
<repository>
  <id>cloudrepo-central-proxy</id>
  <url>https://YOUR_ORG.mycloudrepo.io/repositories/maven-central</url>
</repository>

Nexus Hosted Repositories → CloudRepo Repositories

// build.gradle - Before (Nexus)
repositories {
    maven {
        url "https://nexus.example.com/repository/maven-releases"
        credentials {
            username nexusUsername
            password nexusPassword
        }
    }
}

// build.gradle - After (CloudRepo)
repositories {
    maven {
        url "https://YOUR_ORG.mycloudrepo.io/repositories/maven-releases"
        credentials {
            username cloudrepoUsername
            password cloudrepoToken
        }
    }
}

Nexus Group Repositories → CloudRepo Repository Groups

CloudRepo supports repository groups for aggregating multiple repositories:

<!-- settings.xml for CloudRepo groups -->
<settings>
  <mirrors>
    <mirror>
      <id>cloudrepo-group</id>
      <mirrorOf>*</mirrorOf>
      <url>https://YOUR_ORG.mycloudrepo.io/repositories/maven-group</url>
    </mirror>
  </mirrors>
</settings>

Python/PyPI Configuration

# pip.conf - Before (Nexus)
[global]
index-url = https://nexus.example.com/repository/pypi-all/simple

After the move, delete that index-url line so PyPI is pip’s default index again, and install your private packages from CloudRepo alone with requirements-private.txt, as in Step 4.

CI/CD Pipeline Updates

Jenkins Configuration Changes

Before (Nexus):

pipeline {
    agent any

    environment {
        NEXUS_URL = 'https://nexus.example.com'
        NEXUS_REPOSITORY = 'maven-releases'
        NEXUS_CREDENTIALS = credentials('nexus-credentials')
    }

    stages {
        stage('Deploy') {
            steps {
                sh '''
                    mvn deploy \
                      -DaltDeploymentRepository=nexus::default::${NEXUS_URL}/repository/${NEXUS_REPOSITORY} \
                      -Dusername=${NEXUS_CREDENTIALS_USR} \
                      -Dpassword=${NEXUS_CREDENTIALS_PSW}
                '''
            }
        }
    }
}

After (CloudRepo):

pipeline {
    agent any

    environment {
        CLOUDREPO_URL = 'https://YOUR_ORG.mycloudrepo.io'
        CLOUDREPO_REPOSITORY = 'maven-releases'
        CLOUDREPO_CREDENTIALS = credentials('cloudrepo-credentials')
    }

    stages {
        stage('Deploy to CloudRepo') {
            steps {
                sh '''
                    mvn deploy \
                      -DaltDeploymentRepository=cloudrepo::default::${CLOUDREPO_URL}/repository/${CLOUDREPO_REPOSITORY} \
                      -Dusername=${CLOUDREPO_CREDENTIALS_USR} \
                      -Dpassword=${CLOUDREPO_CREDENTIALS_PSW}
                '''
            }
        }
    }
}

GitHub Actions Updates

Complete workflow example:

name: Build and Deploy to CloudRepo

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

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

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

      - name: Configure Maven for CloudRepo
        run: |
          mkdir -p ~/.m2
          cat > ~/.m2/settings.xml << EOF
          <settings>
            <servers>
              <server>
                <id>cloudrepo-releases</id>
                <username>${{ secrets.CLOUDREPO_USERNAME }}</username>
                <password>${{ secrets.CLOUDREPO_TOKEN }}</password>
              </server>
              <server>
                <id>cloudrepo-snapshots</id>
                <username>${{ secrets.CLOUDREPO_USERNAME }}</username>
                <password>${{ secrets.CLOUDREPO_TOKEN }}</password>
              </server>
            </servers>
            <profiles>
              <profile>
                <id>cloudrepo</id>
                <repositories>
                  <repository>
                    <id>cloudrepo-public</id>
                    <url>https://YOUR_ORG.mycloudrepo.io/repositories/maven-public</url>
                  </repository>
                </repositories>
              </profile>
            </profiles>
            <activeProfiles>
              <activeProfile>cloudrepo</activeProfile>
            </activeProfiles>
          </settings>
          EOF

      - name: Build with Maven
        run: mvn clean package

      - name: Deploy to CloudRepo
        if: github.ref == 'refs/heads/main'
        run: mvn deploy

GitLab CI Modifications

variables:
  MAVEN_OPTS: '-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository'

cache:
  paths:
    - .m2/repository

before_script:
  - apt-get update -qq && apt-get install -y maven
  - |
    cat > ~/.m2/settings.xml << EOF
    <settings>
      <servers>
        <server>
          <id>cloudrepo</id>
          <username>${CLOUDREPO_USERNAME}</username>
          <password>${CLOUDREPO_TOKEN}</password>
        </server>
      </servers>
      <mirrors>
        <mirror>
          <id>cloudrepo</id>
          <mirrorOf>*</mirrorOf>
          <url>https://YOUR_ORG.mycloudrepo.io/repositories/maven-public</url>
        </mirror>
      </mirrors>
    </settings>
    EOF

build:
  stage: build
  script:
    - mvn clean compile

test:
  stage: test
  script:
    - mvn test

deploy:
  stage: deploy
  script:
    - mvn deploy
  only:
    - main
    - tags

Common Challenges and Solutions

Challenge 1: Large Artifact Migration

Problem: Migrating terabytes of artifacts takes too long.

Solution: Use CloudRepo’s bulk import service:

# Contact CloudRepo support for bulk import
# They provide:
# 1. S3 bucket for direct upload
# 2. Parallel processing of your artifacts
# 3. Verification reports

# Or use parallel migration script
find /nexus-data/blobs -type f -name "*.jar" | \
  parallel -j 10 ./migrate-artifact.sh {}

Challenge 2: Custom Nexus Plugins

Problem: Using custom Nexus plugins with no CloudRepo equivalent.

Solutions:

1. Webhook Integration: Replace plugins with CloudRepo webhooks
2. API Automation: Use CloudRepo’s REST API for custom workflows
3. CI/CD Pipeline: Move logic from Nexus plugins to CI/CD

Challenge 3: Repository Cleanup Policies

Problem: Nexus cleanup policies need to be replicated.

Solution: Turn on Snapshot Cleanup in each Maven repository’s settings. It keeps the last N versions of each snapshot artifact and removes the rest. CloudRepo has no age-based cleanup, so express a Nexus age rule as a snapshot count.

Challenge 4: Access Control Differences

Problem: Complex LDAP/Active Directory integration in Nexus.

Solution: CloudRepo supports API tokens today, with SAML SSO on the roadmap:

# Generate API tokens for service accounts
curl -X POST https://api.cloudrepo.io/tokens \
  -H "Authorization: Bearer ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ci-cd-token",
    "permissions": ["read", "write"],
    "repositories": ["maven-releases", "maven-snapshots"]
  }'

Post-Migration Best Practices

Monitoring and Alerts

Set up comprehensive monitoring:

# CloudRepo monitoring endpoints
monitoring:
  health_check: https://YOUR_ORG.mycloudrepo.io/__health__
  metrics: https://api.cloudrepo.io/metrics

alerts:
  - type: download_failures
    threshold: 5
    window: 5m
  - type: upload_failures
    threshold: 3
    window: 5m
  - type: storage_usage
    threshold: 80%

Backup Strategies

CloudRepo provides automatic backups, but consider:

1. Artifact versioning: Keep all versions by default
2. Metadata exports: Regular exports of repository configurations
3. Disaster recovery plan: Document recovery procedures

# Export repository metadata
curl -X GET https://api.cloudrepo.io/repositories/export \
  -H "Authorization: Bearer TOKEN" \
  -o repository-backup-$(date +%Y%m%d).json

Performance Optimization

Optimize CloudRepo usage:

<!-- Use CloudRepo's standard repository URL -->
<repository>
  <id>cloudrepo</id>
  <url>https://YOUR_ORG.mycloudrepo.io/repositories/maven-public</url>
</repository>

Cost Tracking

Monitor and optimize costs:

import requests
from datetime import datetime, timedelta

def get_usage_report():
    """Generate monthly usage report"""
    response = requests.get(
        'https://api.cloudrepo.io/usage',
        headers={'Authorization': f'Bearer {TOKEN}'},
        params={
            'from': (datetime.now() - timedelta(days=30)).isoformat(),
            'to': datetime.now().isoformat()
        }
    )

    usage = response.json()

    # Compare with your actual previous Nexus costs (substitute your real figure):
    nexus_monthly_cost = 0.0  # e.g. from your last month of self-hosting
    cloudrepo_monthly_cost = usage['total_cost']
    difference = nexus_monthly_cost - cloudrepo_monthly_cost

    print(f"Monthly Difference: ${difference:,.2f}")

    return usage

Rollback Plan

While CloudRepo migrations are typically smooth, having a rollback plan provides peace of mind:

1. Keep Nexus in Read-Only Mode

# Set Nexus to read-only
curl -X PUT https://nexus.example.com/service/rest/v1/security/readonly \
  -H "Authorization: Basic $(echo -n admin:password | base64)" \
  -H "Content-Type: application/json" \
  -d '{"enabled": true}'

2. Dual-Publishing Strategy

During transition, publish to both repositories:

// Dual publishing in Jenkins
stage('Deploy') {
    parallel {
        stage('Deploy to CloudRepo') {
            steps {
                sh 'mvn deploy -P cloudrepo'
            }
        }
        stage('Deploy to Nexus') {
            when {
                expression { params.DUAL_PUBLISH == true }
            }
            steps {
                sh 'mvn deploy -P nexus'
            }
        }
    }
}

3. Emergency Rollback Procedure

If rollback is needed:

1. Stop new deployments to CloudRepo
2. Update all configurations back to Nexus URLs
3. Remove Nexus read-only mode
4. Sync any artifacts deployed only to CloudRepo back to Nexus
5. Document issues for CloudRepo support team

Cost Comparison Calculator

Calculate your potential savings:

The self-hosted columns below are illustrative estimates of infrastructure and staffing. Substitute your own numbers. They leave out Sonatype license and support fees, which come from your Sonatype agreement: Sonatype’s published prices are in our Nexus pricing guide. CloudRepo’s prices are its real, published plan rates, shown billed monthly, with no commitment, like the self-hosted costs beside them. Monthly billing runs about 20% higher than annual billing: billed annually, Starter is $199/month billed annually and Business $799/month billed annually.

Small Team (5 developers, 50GB storage)

Medium Team (25 developers, 500GB storage)

Enterprise Team (100+ developers, 5TB storage)

*Enterprise pricing is customized based on storage and support requirements. Contact sales for a quote.

Conclusion: Make the Switch with Confidence

Migrating from Sonatype Nexus to CloudRepo is a strategic decision that delivers immediate cost savings and long-term operational benefits. With this comprehensive guide, you have everything needed for a successful migration:

Quick Wins After Migration

• Day 1: Infrastructure and maintenance overhead gone; billing is flat and predictable
• Week 1: Developers report faster artifact downloads
• Month 1: Zero infrastructure maintenance performed
• Month 3: First avoided Nexus upgrade cycle
• Year 1: Saved enough to fund additional development resources

Next Steps

1. Start 14-Day Free Trial: Sign up at cloudrepo.io/signup
2. Run Cost Analysis: Calculate your specific savings
3. Plan Migration: Use this guide to create your migration plan
4. Get Support: Contact support@cloudrepo.io for migration assistance

Why CloudRepo Wins

• No Infrastructure: Eliminate servers, storage, and maintenance forever
• Predictable Costs: Simple pricing with no hidden fees
• Enterprise Features: Everything you need, nothing you don’t
• Superior Support: Included with every plan, no expensive contracts
• Global Performance: Cloud-backed delivery beats any single Nexus server

For step-by-step instructions, follow the migration process outlined above. Our team is ready to help with any questions.