How to Migrate Linode Container Registry to Vultr Container Registry

Vultr Container Registry is a managed image storage solution that lets you securely store, manage, and distribute Docker container images. It integrates seamlessly with Vultr Kubernetes Engine and centralizes container image management for production workloads.

This guide demonstrates how to migrate container images from a Linode Private Docker Registry to Vultr Container Registry. You will use Docker and Skopeo to perform single-image and bulk transfers between the two registries.

Prerequisites

Before you begin, ensure you have:

• Access to an Ubuntu 24.04 instance as your migration workstation.
• Docker installed on Ubuntu 24.04.
• An existing Linode Private Docker Registry running on a remote instance.
• A provisioned Vultr Container Registry.

Prepare the Source Linode Docker Registry

This section sets up access to your Linode-hosted Docker registry from the migration workstation and verifies available repositories and image tags.

1. Add your user to the docker group to run Docker commands without sudo.

   console Copy

   $ sudo usermod -aG docker $USER
   

2. Apply the group change in your current shell.

   console Copy

   $ newgrp docker
   

3. Log in to the Linode Docker Registry.

   console Copy

   $ docker login <ip-address>:<port> -u <username>
   

   Replace:

   • <ip-address> with your Linode registry’s IP address.
   • <port> with the exposed registry port (e.g., 5000).
   • <username> with your registry username.

   If the registry is running behind Kubernetes, use the appropriate Ingress or LoadBalancer endpoint instead.

   When prompted, enter your password. If successful, the output displays:

   Login Succeeded

   Note

   If Docker returns http: server gave HTTP response to HTTPS client, configure it to allow insecure registries.

   1. Open the Docker daemon config.

      console Copy

      $ sudo nano /etc/docker/daemon.json
      

   2. Add the insecure registry address.

      ini Copy

      {
        "insecure-registries": ["<ip-address>:<port>"]
      }
      

      Save and close the file.

   3. Restart Docker to apply the changes.

      console Copy

      $ sudo systemctl restart docker
      

   4. Re-run the Docker login command.

4. List all repositories in the Linode registry.

   console Copy

   $ curl -u <username>:<password> http://<ip-address>:<port>/v2/_catalog
   

   Output:

   {"repositories":["app1/alpine","app1/nginx","app2/busybox","app2/redis"]}

5. List tags for a specific image, such as app1/nginx.

   console Copy

   $ curl -u <username>:<password> http://<ip-address>:<port>/v2/<repository>/tags/list
   

   Output:

   {"name":"app1/nginx","tags":["latest"]}

   Take note of the images and tags to migrate.

Set Up the Vultr Container Registry

1. Log in to the Vultr Customer Portal and go to Products > Container Registry.

2. Select the container registry you created. For example, the registry name might be myvultrregistry.

   

3. Note down the following from the registry overview:

   • Registry URL
   • Username
   • API Key

   These values will be used for authentication and image pushes in later steps.

   

Migrate the Container Registries

In this section, you will migrate images from your Linode Docker Registry to the Vultr Container Registry using Docker and Skopeo.

Verify and Test the Vultr Container Registry Images

After completing the migration, confirm that the images are available in your Vultr Container Registry and function as expected.

1. Open the Vultr Customer Portal and navigate to Container Registry > Repositories. Confirm that your expected repositories and images are present.

   

2. Pull a migrated image from the Vultr Container Registry.

   console Copy

   $ docker image pull <registry-url>/<image>:<tag>
   

3. Run the container to verify that it starts successfully.

   console Copy

   $ docker container run -d --name test-image2 <registry-url>/<image>:<tag>
   

4. List running containers to confirm the image is up and running:

   console Copy

   $ docker container ls
   

   Output:

   CONTAINER ID   IMAGE                                         COMMAND     CREATED         STATUS         PORTS     NAMES
   67f14735ae8d   ewr.vultrcr.com/myvultrregistry/app1/alpine   "/bin/sh"   3 seconds ago   Up 2 seconds             test-image

   This confirms that the container was successfully pulled and launched from the Vultr registry.

Validate Image Integrity with Skopeo

You can verify the consistency of image digests between the source and destination registries using Skopeo.

1. Create a script named verify-images.sh:

   bash Copy

   #!/bin/bash
   LINODE_REGISTRY="<ip-address>:<port>"
   LINODE_USERNAME="<username>"
   LINODE_PASSWORD="<password>"
   VULTR_REGISTRY="<vultr-registry-url>"
   REPOS=("app1/alpine" "app1/nginx" "app2/busybox" "app2/redis")
   
   for repo in "${REPOS[@]}"; do
       tags=$(curl -s -u "$LINODE_USERNAME:$LINODE_PASSWORD" http://"$LINODE_REGISTRY/v2/$repo/tags/list" \
          | grep -o '"tags":\[[^]]*\]' | sed 's/"tags":\[//' | sed 's/\]//' \
          | tr ',' '\n' | sed 's/"//g' | grep -v "^$repo$")
   
       for tag in $tags; do
           linode_digest=$(skopeo inspect --tls-verify=false docker://"$LINODE_REGISTRY/$repo:$tag" | grep Digest | sed 's/.*"\([^"]*\)".*/\1/')
           vultr_digest=$(skopeo inspect docker://"$VULTR_REGISTRY/$repo:$tag" | grep Digest | sed 's/.*"\([^"]*\)".*/\1/')
           [ "$linode_digest" = "$vultr_digest" ] && echo "$repo:$tag OK" || echo "$repo:$tag FAIL"
       done
   done
   

2. Make the script executable.

   console Copy

   $ chmod +x verify-images.sh
   

3. Run the script.

   console Copy

   $ ./verify-images.sh
   

   Output:

   app1/alpine:latest OK
   app1/nginx:latest OK
   app2/busybox:latest OK
   app2/redis:latest OK

   This confirms that the image digests are identical in both Linode and Vultr registries, validating the integrity of your migrated images.

Cutover to Vultr Container Registry

After completing the image migration, update all configurations and systems to use your Vultr Container Registry.

1. Update configuration files

   Modify any Dockerfiles, Kubernetes manifests, Helm charts, and Docker Compose files to pull images from your Vultr Container Registry.

   yaml Copy

   ...
   image: <vultr-registry-url>/<image>:<tag>
   ...
   

2. Update CI/CD pipelines

   Point your CI/CD workflows to the new Vultr registry and update any related image paths or authentication configurations.

3. Verify authentication

   Ensure that all CI/CD tools and orchestration platforms (such as Kubernetes or Nomad) are properly authenticated against your Vultr Container Registry using the correct credentials or secrets.

4. Monitor deployment behavior

   Review logs, container statuses, and deployment outputs to verify that services are pulling and running images from the correct (Vultr) source.

5. Decommission the Linode registry

   Once migration is complete and validated:

   • Shut down and remove the Linode-hosted Docker registry container.

   • Clean up old Docker credentials and environment-specific configurations tied to the Linode registry.

   • If you configured Docker to allow insecure connections to the Linode registry, remove the entry from /etc/docker/daemon.json:

     json Copy

     {
     "insecure-registries": []
     }
     

   Then restart Docker to apply the changes.

   console Copy

   $ sudo systemctl restart docker
   

Conclusion

In this guide, you migrated container images from a Linode Private Docker Registry to the Vultr Container Registry using both Docker and Skopeo. You verified the migration, ensured image integrity, and updated your infrastructure to use the Vultr Container Registry for ongoing deployments.

For more information, refer to the official Vultr Container Registry documentation.