JFrog Artifactory to CloudRepo Migration Guide

repositories:
  maven:
    - name: libs-release
      type: local
      package_type: maven
      size: 850GB
      artifacts: 125000

    - name: libs-snapshot
      type: local
      package_type: maven
      size: 420GB
      artifacts: 89000
      cleanup_policy: 30_days

    - name: maven-central
      type: remote
      url: https://repo1.maven.org/maven2
      cache_size: 200GB

docker: - name: docker-local
type: local
package_type: docker
size: 1.2TB
images: 3400

npm: - name: npm-local
type: local
package_type: npm
size: 180GB
packages: 45000

import requests
import json

# Read Artifactory repository configurations

with open('repository-inventory.yaml', 'r') as f:
inventory = yaml.safe_load(f)

cloudrepo_api = "https://your-org.cloudrepo.io/api/v1"
auth = ("username", "password")

for repo_type, repos in inventory['repositories'].items():
for repo in repos: # Create CloudRepo repository
payload = {
"name": repo['name'],
"type": repo_type,
"description": f"Migrated from Artifactory {repo['name']}"
}

        response = requests.post(
            f"{cloudrepo_api}/repositories",
            json=payload,
            auth=auth
        )

        if response.status_code == 201:
            print(f"Created repository: {repo['name']}")
        else:
            print(f"Failed to create {repo['name']}: {response.text}")

#!/bin/bash
# Install JFrog CLI if not present

if ! command -v jf &> /dev/null; then
curl -fL https://getcli.jfrog.io/v2 | sh
chmod +x jf
sudo mv jf /usr/local/bin/
fi

# Configure JFrog CLI

jf config add artifactory-server \
 --artifactory-url="https://artifactory.example.com/artifactory" \
 --user="admin" \
 --password="password"

# Export repositories

REPOS=(
"libs-release"
"libs-snapshot"
"docker-local"
"npm-local"
)

for repo in "${REPOS[@]}"; do
echo "Exporting $repo..."

# Create export directory

mkdir -p exports/$repo

# Download all artifacts from repository

jf rt download \
 "$repo/*" \
    "exports/$repo/" \
 --flat=false \
 --threads=10 \
 --retry=3

# Generate manifest

find exports/$repo -type f | \
    sed "s|exports/$repo/||" > exports/$repo.manifest

echo "Exported $(wc -l < exports/$repo.manifest) artifacts from $repo"
done

#!/usr/bin/env python3
import os
import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
import hashlib

CLOUDREPO_URL = "https://your-org.cloudrepo.io"
AUTH = ("username", "password")
MAX_WORKERS = 10

def calculate_checksum(file_path):
"""Calculate SHA256 checksum of file."""
sha256_hash = hashlib.sha256()
with open(file_path, "rb") as f:
for byte_block in iter(lambda: f.read(4096), b""):
sha256_hash.update(byte_block)
return sha256_hash.hexdigest()

def upload_artifact(local_path, repo_name, artifact_path):
"""Upload single artifact to CloudRepo."""
url = f"{CLOUDREPO_URL}/repository/{repo_name}/{artifact_path}"

    # Calculate checksum
    checksum = calculate_checksum(local_path)

    # Upload file
    with open(local_path, 'rb') as f:
        headers = {
            'X-Checksum-SHA256': checksum
        }
        response = requests.put(
            url,
            data=f,
            auth=AUTH,
            headers=headers
        )

    if response.status_code == 201:
        return f"✓ {artifact_path}"
    else:
        return f"✗ {artifact_path}: {response.status_code}"

def migrate_repository(repo_name, export_dir):
"""Migrate entire repository to CloudRepo."""
export_path = Path(export_dir)
artifacts = list(export_path.rglob('\*'))
artifacts = [a for a in artifacts if a.is_file()]

    print(f"Migrating {len(artifacts)} artifacts from {repo_name}")

    results = []
    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        futures = {}

        for artifact_file in artifacts:
            relative_path = artifact_file.relative_to(export_path)
            future = executor.submit(
                upload_artifact,
                str(artifact_file),
                repo_name,
                str(relative_path)
            )
            futures[future] = str(relative_path)

        for future in as_completed(futures):
            result = future.result()
            print(result)
            results.append(result)

    successful = len([r for r in results if r.startswith('✓')])
    print(f"Migration complete: {successful}/{len(artifacts)} artifacts uploaded")

# Migrate all repositories

repositories = [
("libs-release", "exports/libs-release"),
("libs-snapshot", "exports/libs-snapshot"),
("docker-local", "exports/docker-local"),
("npm-local", "exports/npm-local"),
]

for repo_name, export_dir in repositories:
migrate_repository(repo_name, export_dir)

<settings>
  <servers>
    <server>
      <id>cloudrepo-releases</id>
      <username>${env.CLOUDREPO_USER}</username>
      <password>${env.CLOUDREPO_API_TOKEN}</password>
    </server>
    <server>
      <id>cloudrepo-snapshots</id>
      <username>${env.CLOUDREPO_USER}</username>
      <password>${env.CLOUDREPO_API_TOKEN}</password>
    </server>
  </servers>

<mirrors>
  <mirror>
    <id>cloudrepo-central</id>
    <mirrorOf>central</mirrorOf>
    <url>https://your-org.mycloudrepo.io/repositories/maven-central/</url>
  </mirror>
</mirrors>

  <profiles>
    <profile>
      <id>cloudrepo</id>
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>
      <repositories>
        <repository>
          <id>cloudrepo-releases</id>
          <url>https://your-org.mycloudrepo.io/repositories/libs-release/</url>
          <releases>
            <enabled>true</enabled>
          </releases>
          <snapshots>
            <enabled>false</enabled>
          </snapshots>
        </repository>
        <repository>
          <id>cloudrepo-snapshots</id>
          <url>https://your-org.mycloudrepo.io/repositories/libs-snapshot/</url>
          <releases>
            <enabled>false</enabled>
          </releases>
          <snapshots>
            <enabled>true</enabled>
          </snapshots>
        </repository>
      </repositories>
    </profile>
  </profiles>
</settings>

cloudrepoUrl=https://your-org.cloudrepo.io
cloudrepoUsername=your-username
cloudrepoPassword=YOUR_API_TOKEN

// build.gradle
repositories {
maven {
url "${cloudrepoUrl}/repository/libs-release/"
        credentials {
            username cloudrepoUsername
            password cloudrepoPassword
        }
    }
    maven {
        url "${cloudrepoUrl}/repository/libs-snapshot/"
credentials {
username cloudrepoUsername
password cloudrepoPassword
}
}
}

publishing {
repositories {
maven {
name = 'cloudrepo'
url = uri("${cloudrepoUrl}/repository/libs-${version.endsWith('SNAPSHOT') ? 'snapshot' : 'release'}/")
credentials {
username = cloudrepoUsername
password = cloudrepoPassword
}
}
}
}

import json
import requests

# Load virtual repository configurations

with open('virtual-repos.json', 'r') as f:
virtual_repos = json.load(f)

cloudrepo_api = "https://your-org.cloudrepo.io/api/v1"
auth = ("username", "password")

for vrepo in virtual_repos: # Create repository group in CloudRepo
group_config = {
"name": vrepo['key'],
"type": "group",
"repositories": vrepo['repositories'],
"description": f"Migrated virtual repository from Artifactory"
}

    response = requests.post(
        f"{cloudrepo_api}/repository-groups",
        json=group_config,
        auth=auth
    )

    if response.status_code == 201:
        print(f"Created repository group: {vrepo['key']}")
        print(f"  Members: {', '.join(vrepo['repositories'])}")

import json
import requests
import random
import string

def generate_password():
"""Generate secure random password."""
return ''.join(random.choices(
string.ascii_letters + string.digits + string.punctuation,
k=16
))

# Load Artifactory users

with open('users.json', 'r') as f:
artifactory_users = json.load(f)

cloudrepo_api = "https://your-org.cloudrepo.io/api/v1"
auth = ("admin", "admin_password")

user_mappings = []

for user in artifactory_users: # Skip system users
if user['name'] in ['anonymous', '_internal']:
continue

    # Generate new password for CloudRepo
    new_password = generate_password()

    # Create user in CloudRepo
    user_data = {
        "username": user['name'],
        "email": user['email'],
        "password": new_password,
        "roles": ["developer"]  # Map Artifactory roles to CloudRepo roles
    }

    response = requests.post(
        f"{cloudrepo_api}/users",
        json=user_data,
        auth=auth
    )

    if response.status_code == 201:
        user_mappings.append({
            "username": user['name'],
            "email": user['email'],
            "password": new_password
        })
        print(f"Created user: {user['name']}")

# Save user mappings for distribution

with open('cloudrepo_users.json', 'w') as f:
json.dump(user_mappings, f, indent=2)

print(f"\nMigrated {len(user_mappings)} users")
print("User credentials saved to cloudrepo_users.json")

name: Build and Deploy

on:
push:
branches: [main]

jobs:
build:
runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

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

      - name: Configure Maven for CloudRepo
        run: |
          mkdir -p ~/.m2
          cat > ~/.m2/settings.xml <<EOF
          <settings>
            <servers>
              <server>
                <id>cloudrepo</id>
                <username>${{ secrets.CLOUDREPO_USERNAME }}</username>
                <password>${{ secrets.CLOUDREPO_API_TOKEN }}</password>
              </server>
            </servers>
          </settings>
          EOF

      - name: Build and Deploy
        run: |
          mvn clean deploy \
            -DaltDeploymentRepository=cloudrepo::default::https://your-org.mycloudrepo.io/repositories/libs-release/
        env:
          CLOUDREPO_USERNAME: ${{ secrets.CLOUDREPO_USERNAME }}
          CLOUDREPO_API_TOKEN: ${{ secrets.CLOUDREPO_API_TOKEN }}

variables:
  CLOUDREPO_URL: "https://your-org.cloudrepo.io"
  MAVEN_OPTS: "-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository"

cache:
paths: - .m2/repository/

before_script:

- |
  cat > ~/.m2/settings.xml <<EOF
  <settings>
    <servers>
      <server>
        <id>cloudrepo</id>
        <username>${CLOUDREPO_USERNAME}</username>
        <password>${CLOUDREPO_API_TOKEN}</password>
      </server>
    </servers>
  </settings>
  EOF

build:
stage: build
script: - mvn clean compile

test:
stage: test
script: - mvn test

deploy:
stage: deploy
script: - |
mvn deploy \
 -DaltDeploymentRepository=cloudrepo::default::${CLOUDREPO_URL}/repository/libs-release/
only: - main

#!/bin/bash
echo "CloudRepo Migration Validation"
echo "=============================="

# Test authentication

echo -n "Testing authentication... "
if curl -s -u $CLOUDREPO_USER:$CLOUDREPO_API_TOKEN \
 "$CLOUDREPO_URL/api/v1/account/info" > /dev/null; then
echo "✓"
else
echo "✗"
exit 1
fi

# Test artifact download

echo -n "Testing artifact download... "
if curl -s -u $CLOUDREPO_USER:$CLOUDREPO_API_TOKEN \
 "$CLOUDREPO_URL/repository/libs-release/com/example/app/1.0/app-1.0.jar" \
 -o /tmp/test-artifact.jar; then
echo "✓"
else
echo "✗"
fi

# Test artifact upload

echo -n "Testing artifact upload... "
echo "test" > /tmp/test-file.txt
if curl -s -u $CLOUDREPO_USER:$CLOUDREPO_API_TOKEN \
 -X PUT \
 -T /tmp/test-file.txt \
 "$CLOUDREPO_URL/repository/libs-release/test/migration/test.txt"; then
echo "✓"
else
echo "✗"
fi

# Test build tool integration

echo -n "Testing Maven build... "
cd sample-project
if mvn clean compile > /dev/null 2>&1; then
echo "✓"
else
echo "✗"
fi

# Compare artifact counts

echo -e "\nArtifact Count Comparison:"
echo "-------------------------"
for repo in libs-release libs-snapshot npm-local; do
artifactory_count=$(grep -c "$repo" exports/$repo.manifest 2>/dev/null || echo 0)
    cloudrepo_count=$(curl -s -u $CLOUDREPO_USER:$CLOUDREPO_API_TOKEN \
 "$CLOUDREPO_URL/api/v1/repositories/$repo/statistics" | \
 jq '.artifactCount' 2>/dev/null || echo 0)

    if [ "$artifactory_count" -eq "$cloudrepo_count" ]; then
        status="✓"
    else
        status="✗"
    fi

    printf "%-20s Artifactory: %6d  CloudRepo: %6d  %s\n" \
        "$repo" "$artifactory_count" "$cloudrepo_count" "$status"

done

echo -e "\nValidation complete!"

#!/bin/bash
# Create final backup

echo "Creating final Artifactory backup..."
curl -X POST -u admin:password \
 "https://artifactory.example.com/artifactory/api/system/backup" \
 -H "Content-Type: application/json" \
 -d '{
"key": "final-backup-$(date +%Y%m%d)",
"includeBuilds": true,
"includeConfig": true
}'

# Export audit logs

echo "Exporting audit logs..."
tar -czf artifactory-logs-$(date +%Y%m%d).tar.gz \
 /var/log/artifactory/

# Update DNS/Load Balancer (if using CNAME)

echo "Update DNS to point to CloudRepo:"
echo " artifactory.example.com → your-org.cloudrepo.io"

# Notify teams

echo "Sending migration completion notification..."
curl -X POST https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK \
 -H 'Content-Type: application/json' \
 -d '{
"text": "Artifactory migration complete! New repository URL: https://your-org.cloudrepo.io",
"attachments": [{
"color": "good",
"fields": [
{"title": "Status", "value": "Migration complete", "short": true},
{"title": "New Registry", "value": "your-org.cloudrepo.io", "short": true}
]
}]
}'

# Schedule Artifactory shutdown

echo "Artifactory will be shut down in 30 days"
echo "Final backup location: /backups/artifactory/final-backup-$(date +%Y%m%d)"

#!/bin/bash
# Configure npm for CloudRepo

npm config set registry https://your-org.mycloudrepo.io/repositories/npm-group/
npm config set always-auth true
npm config set _auth $(echo -n "$CLOUDREPO_USER:$CLOUDREPO_API_TOKEN" | base64)

# Export NPM packages from Artifactory

cd exports/npm-local

for package in $(find . -name "*.tgz"); do
echo "Publishing $package to CloudRepo"
npm publish $package --registry https://your-org.mycloudrepo.io/repositories/npm-local/
done

# Python/PyPI migration

pip config set global.index-url https://$CLOUDREPO_USER:$CLOUDREPO_API_TOKEN@your-org.mycloudrepo.io/repositories/pypi-group/simple

# Upload Python packages

for package in $(find exports/pypi-local -name "*.whl" -o -name "*.tar.gz"); do
twine upload \
 --repository-url https://your-org.mycloudrepo.io/repositories/pypi-local/ \
 -u $CLOUDREPO_USER \
 -p $CLOUDREPO_API_TOKEN \
 $package
done

import requests
import schedule
import time

def replicate_artifacts():
"""Replicate artifacts between CloudRepo instances."""
source_api = "https://primary.cloudrepo.io/api/v1"
target_api = "https://backup.cloudrepo.io/api/v1"

    # Get list of recent artifacts
    response = requests.get(
        f"{source_api}/repositories/libs-release/artifacts",
        params={"since": "24h"},
        auth=("user", "pass")
    )

    for artifact in response.json():
        # Download from source
        artifact_data = requests.get(
            artifact['downloadUrl'],
            auth=("user", "pass")
        )

        # Upload to target
        requests.put(
            f"{target_api}/repositories/libs-release/{artifact['path']}",
            data=artifact_data.content,
            auth=("user", "pass")
        )

# Schedule replication every hour

schedule.every().hour.do(replicate_artifacts)

while True:
schedule.run_pending()
time.sleep(60)

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-deploy-plugin</artifactId>
      <version>3.0.0</version>
      <configuration>
        <uniqueVersion>false</uniqueVersion>
      </configuration>
    </plugin>
  </plugins>
</build>

permission_mapping = {
    "artifactory-admin": "cloudrepo-admin",
    "artifactory-deployer": "cloudrepo-developer",
    "artifactory-reader": "cloudrepo-reader",
    "artifactory-anonymous": None  # No anonymous access in CloudRepo
}

def map_user_permissions(artifactory_user):
"""Map Artifactory permissions to CloudRepo roles."""
cloudrepo_roles = []

    for perm in artifactory_user['permissions']:
        if perm['repository'] == '*':
            cloudrepo_roles.append('admin')
        elif 'write' in perm['actions']:
            cloudrepo_roles.append('developer')
        elif 'read' in perm['actions']:
            cloudrepo_roles.append('reader')

    return list(set(cloudrepo_roles))  # Remove duplicates

#!/bin/bash
# Force download of all dependencies

mvn dependency:go-offline

# For Gradle

gradle build --refresh-dependencies

# For NPM

npm install --force

# For Python

pip download -r requirements.txt -d /tmp/pip-cache
for package in /tmp/pip-cache/*.whl; do
twine upload $package
done

optimizations:
  caching:
    - Enable aggressive caching for release artifacts
    - Set 30-day cache for snapshots
    - Use standard CloudRepo endpoints for read-heavy repositories

networking: - Configure region-specific endpoints - Enable HTTP/2 for better multiplexing - Use connection pooling in CI/CD

artifacts: - Enable compression for text artifacts - Use shallow cloning for large repositories - Implement artifact cleanup policies

import requests
from datetime import datetime, timedelta

def analyze_usage():
"""Analyze CloudRepo usage and costs."""
api_url = "https://your-org.cloudrepo.io/api/v1"
auth = ("admin", "password")

    # Get storage metrics
    storage = requests.get(
        f"{api_url}/account/storage",
        auth=auth
    ).json()

    # Get bandwidth metrics
    bandwidth = requests.get(
        f"{api_url}/account/bandwidth",
        params={"days": 30},
        auth=auth
    ).json()

    # Calculate costs
    storage_gb = storage['used'] / 1024 / 1024 / 1024
    monthly_cost = calculate_monthly_cost(storage_gb)

    print(f"Storage Used: {storage_gb:.2f} GB")
    print(f"Monthly Bandwidth: {bandwidth['total']:.2f} GB")
    print(f"Estimated Monthly Cost: ${monthly_cost:.2f}")

    # Fill in your actual current JFrog Artifactory bill (e.g. from your latest invoice):
    your_jfrog_monthly_cost = 0.0
    print(f"vs. JFrog Artifactory: ${your_jfrog_monthly_cost:.2f}")
    print(f"Monthly Difference: ${your_jfrog_monthly_cost - monthly_cost:.2f}")

analyze_usage()

import requests
import concurrent.futures

def deploy_to_both(artifact_path, artifact_data):
"""Deploy artifact to both Artifactory and CloudRepo."""
results = {}

    with concurrent.futures.ThreadPoolExecutor() as executor:
        # Deploy to Artifactory
        artifactory_future = executor.submit(
            deploy_to_artifactory,
            artifact_path,
            artifact_data
        )

        # Deploy to CloudRepo
        cloudrepo_future = executor.submit(
            deploy_to_cloudrepo,
            artifact_path,
            artifact_data
        )

        results['artifactory'] = artifactory_future.result()
        results['cloudrepo'] = cloudrepo_future.result()

    return results

def deploy_to_artifactory(path, data):
return requests.put(
f"https://artifactory.example.com/artifactory/libs-release/{path}",
data=data,
auth=("user", "pass")
)

def deploy_to_cloudrepo(path, data):
return requests.put(
f"https://your-org.mycloudrepo.io/repositories/libs-release/{path}",
data=data,
auth=("user", "pass")
)

#!/bin/bash
# Keep Artifactory in read-only mode

curl -X POST -u admin:password \
 "https://artifactory.example.com/artifactory/api/system/configuration" \
 -H "Content-Type: application/xml" \
 -d '<config><security><anonAccessEnabled>false</anonAccessEnabled></security></config>'

# Sync recent changes back to Artifactory if needed

sync_to_artifactory() {

# Get artifacts created in last 24 hours

recent_artifacts=$(curl -s \
    "$CLOUDREPO_URL/api/v1/artifacts?since=24h" \
 -u $CLOUDREPO_USER:$CLOUDREPO_API_TOKEN)

# Sync back to Artifactory

for artifact in $recent_artifacts; do
    curl -X PUT \
      "https://artifactory.example.com/artifactory/$artifact" \
 -u admin:password \
 -T "$artifact"
done
}

# Quick rollback DNS

rollback_dns() {
echo "nameserver artifactory.example.com" > /etc/resolv.conf
systemctl restart networking
}

import hashlib
import requests
from pathlib import Path

def validate_artifacts(manifest_file):
"""Validate all artifacts were migrated correctly."""
validation_results = []

    with open(manifest_file, 'r') as f:
        artifacts = f.readlines()

    for artifact_path in artifacts:
        artifact_path = artifact_path.strip()

        # Get checksum from Artifactory
        artifactory_checksum = get_artifactory_checksum(artifact_path)

        # Get checksum from CloudRepo
        cloudrepo_checksum = get_cloudrepo_checksum(artifact_path)

        # Compare
        if artifactory_checksum == cloudrepo_checksum:
            status = "✓"
        else:
            status = "✗"

        validation_results.append({
            "path": artifact_path,
            "status": status,
            "artifactory_sha": artifactory_checksum,
            "cloudrepo_sha": cloudrepo_checksum
        })

    # Generate report
    success_count = sum(1 for r in validation_results if r['status'] == "✓")
    total_count = len(validation_results)

    print(f"Validation Results: {success_count}/{total_count} artifacts match")

    # Save detailed report
    with open('validation_report.json', 'w') as f:
        json.dump(validation_results, f, indent=2)

    return success_count == total_count

def get_artifactory_checksum(artifact_path):
response = requests.head(
f"https://artifactory.example.com/artifactory/libs-release/{artifact_path}",
auth=("user", "pass")
)
return response.headers.get('X-Checksum-SHA256', '')

def get_cloudrepo_checksum(artifact_path):
response = requests.head(
f"https://your-org.mycloudrepo.io/repositories/libs-release/{artifact_path}",
auth=("user", "pass")
)
return response.headers.get('X-Checksum-SHA256', '')

# Run validation

if validate_artifacts('migration_manifest.txt'):
print("✓ Migration validation successful!")
else:
print("✗ Validation failed - check validation_report.json")