diff --git a/Dockerfile.downloads b/Dockerfile.downloads
index 2929de86560..288447fd395 100644
--- a/Dockerfile.downloads
+++ b/Dockerfile.downloads
@@ -18,14 +18,13 @@ FROM registry.access.redhat.com/ubi9/ubi-minimal:latest
 RUN mkdir -p /opt/downloads
 
 COPY --from=gobuilder /go/src/github.com/openshift/console/bin/downloads /opt/downloads
-COPY --from=gobuilder /go/src/github.com/openshift/console/cmd/downloads/config/defaultArtifactsConfig.yaml /opt/downloads
 COPY --from=origincli /usr/share/openshift /usr/share/openshift
 
 WORKDIR /
 
 # doesn't require a root user.
 USER 1001
-CMD ["/opt/downloads/downloads",  "--config-path=/opt/downloads/defaultArtifactsConfig.yaml"]
+CMD ["/opt/downloads/downloads"]
 
 LABEL \
         io.k8s.display-name="CLI Artifacts Downloads Server" \
diff --git a/cmd/downloads/config/downloads_config.go b/cmd/downloads/config/downloads_config.go
index eaa38233321..e975afd69c9 100644
--- a/cmd/downloads/config/downloads_config.go
+++ b/cmd/downloads/config/downloads_config.go
@@ -3,8 +3,10 @@ package config
 import (
 	"archive/tar"
 	"archive/zip"
+	"compress/gzip"
 	"fmt"
 	"io"
+	"io/fs"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -13,8 +15,7 @@ import (
 	"text/template"
 
 	"gopkg.in/yaml.v3"
-
-	klog "k8s.io/klog/v2"
+	"k8s.io/klog/v2"
 )
 
 // HtmlPageData holds data passed to the HTML template
@@ -54,7 +55,6 @@ type ArtifactSpec struct {
 
 // ArtifactsConfig holds the configuration for the artifacts server
 type DownloadsServerConfig struct {
-	Port         string
 	Spec         []ArtifactSpec
 	TempDir      string
 	TemplateHTML *template.Template
@@ -80,7 +80,7 @@ const templateStringHTML = `<!DOCTYPE html>
 	<ul>
 		{{ range .Items }}
             {{ if eq .Type "binary" }}
-                <li><a href="{{ .URL }}">oc ({{ .Name }})</a> (<a href="{{ .TarURL }}">tar</a> <a href="{{ .ZipURL }}">zip</a>)</li>
+                <li><a href="{{ .URL }}">oc ({{ .Name }})</a> (<a href="{{ .TarURL }}">tar.gz</a> <a href="{{ .ZipURL }}">zip</a>)</li>
             {{ else if eq .Type "license" }}
                 <li><a href="{{ .URL }}">license</a></li>
             {{ end }}
@@ -91,16 +91,11 @@ const templateStringHTML = `<!DOCTYPE html>
 </html>`
 
 // load artifacts to be served from given path
-func loadArtifactsSpec(path string) ([]ArtifactSpec, error) {
+func loadArtifactsSpec(dlConfigBytes []byte) ([]ArtifactSpec, error) {
 	specs := ArtifactsConfig{}
-	// open the JSON spec config file
-	fileBytes, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
 
 	// unmarshal the YAML file into the ArtifactsConfig object
-	err = yaml.Unmarshal(fileBytes, &specs)
+	err := yaml.Unmarshal(dlConfigBytes, &specs)
 	if err != nil {
 		return nil, err
 	}
@@ -114,7 +109,7 @@ func loadArtifactsSpec(path string) ([]ArtifactSpec, error) {
 }
 
 // NewDownloadsServerConfig creates a new ArtifactsConfig object
-func NewDownloadsServerConfig(port int, specsFilePath string) (*DownloadsServerConfig, error) {
+func NewDownloadsServerConfig(dlConfigBytes []byte) (*DownloadsServerConfig, error) {
 	tempDir := defaultArtifactsDir
 	matches, _ := filepath.Glob("/tmp/artifacts*")
 	for _, match := range matches {
@@ -124,7 +119,7 @@ func NewDownloadsServerConfig(port int, specsFilePath string) (*DownloadsServerC
 		return nil, fmt.Errorf("failed to create artifacts directory: %w", err)
 	}
 	klog.Info("Created artifacts directory (cleaned up any stale data from previous runs)")
-	specs, err := loadArtifactsSpec(specsFilePath)
+	specs, err := loadArtifactsSpec(dlConfigBytes)
 	if err != nil {
 		return nil, err
 	}
@@ -136,7 +131,6 @@ func NewDownloadsServerConfig(port int, specsFilePath string) (*DownloadsServerC
 	}
 
 	artifactsConfig := DownloadsServerConfig{
-		Port:         fmt.Sprintf("%d", port),
 		Spec:         specs,
 		TempDir:      tempDir,
 		TemplateHTML: templateHTML,
@@ -150,20 +144,7 @@ func NewDownloadsServerConfig(port int, specsFilePath string) (*DownloadsServerC
 	return &artifactsConfig, nil
 }
 
-func addFileToTar(tw *tar.Writer, filename string) error {
-	// Open the archive
-	file, err := os.Open(filename)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	// Get file information
-	info, err := file.Stat()
-	if err != nil {
-		return err
-	}
-
+func addFileToTar(tw *tar.Writer, file io.Reader, info fs.FileInfo) error {
 	// Create a tar Header from the FileInfo data
 	header, err := tar.FileInfoHeader(info, info.Name())
 	if err != nil {
@@ -185,26 +166,15 @@ func addFileToTar(tw *tar.Writer, filename string) error {
 	return nil
 }
 
-func addFileToZip(zw *zip.Writer, filename string) error {
-	// Open the archive
-	file, err := os.Open(filename)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	// Get file information
-	info, err := file.Stat()
-	if err != nil {
-		return err
-	}
-
+func addFileToZip(zw *zip.Writer, file io.Reader, fileInfo fs.FileInfo) error {
 	// Create a zip header based on the file's information
-	header, err := zip.FileInfoHeader(info)
+	header, err := zip.FileInfoHeader(fileInfo)
 	if err != nil {
 		return err
 	}
 
+	header.Method = zip.Deflate
+
 	// Create a new writer for the file in the zip archive
 	writer, err := zw.CreateHeader(header)
 	if err != nil {
@@ -242,6 +212,17 @@ func configureArchivePath(pathToTargetFile string) string {
 
 // create archive for the target binary
 func createArchive(pathToTargetFile string, format string) error {
+	targetFileInfo, err := os.Stat(pathToTargetFile)
+	if err != nil {
+		return err
+	}
+
+	targetFile, err := os.Open(pathToTargetFile)
+	if err != nil {
+		return err
+	}
+	defer targetFile.Close()
+
 	// create archive in the same directory as the target binary
 	pathToArchive := configureArchivePath(pathToTargetFile) + format
 
@@ -251,14 +232,24 @@ func createArchive(pathToTargetFile string, format string) error {
 	}
 
 	defer file.Close()
-	if format == ".tar" {
-		archiveWriter := tar.NewWriter(file)
-		addFileToTar(archiveWriter, pathToTargetFile)
+	if format == ".tar.gz" {
+		compressWriter := gzip.NewWriter(file)
+		defer compressWriter.Close()
+		archiveWriter := tar.NewWriter(compressWriter)
 		defer archiveWriter.Close()
+
+		err = addFileToTar(archiveWriter, targetFile, targetFileInfo)
+		if err != nil {
+			return fmt.Errorf("could not create archive for %s: %w", pathToTargetFile, err)
+		}
 	} else if format == ".zip" {
 		archiveWriter := zip.NewWriter(file)
-		addFileToZip(archiveWriter, pathToTargetFile)
 		defer archiveWriter.Close()
+		err = addFileToZip(archiveWriter, targetFile, targetFileInfo)
+
+		if err != nil {
+			return fmt.Errorf("could not create archive for %s: %w", pathToTargetFile, err)
+		}
 	} else {
 		return fmt.Errorf("unsupported archive type")
 	}
@@ -351,7 +342,7 @@ func (downloadsConfig *DownloadsServerConfig) generateDirFileContents() ([]ListI
 			Type:   Binary,
 			URL:    relPath,
 			Name:   displayName(spec.Arch, spec.OperatingSystem, basename),
-			TarURL: fmt.Sprintf("%s.tar", relArchivePath),
+			TarURL: fmt.Sprintf("%s.tar.gz", relArchivePath),
 			ZipURL: fmt.Sprintf("%s.zip", relArchivePath),
 		})
 	}
@@ -373,7 +364,7 @@ func (c *DownloadsServerConfig) CreateArchivesInBackground() {
 		wg.Add(2)
 		go func(p string) {
 			defer wg.Done()
-			if err := createArchive(p, ".tar"); err != nil {
+			if err := createArchive(p, ".tar.gz"); err != nil {
 				klog.Errorf("Failed to create tar archive for %s: %v", p, err)
 			}
 		}(artifactPath)
@@ -397,9 +388,21 @@ func (c *DownloadsServerConfig) CreateArchivesInBackground() {
 func (c *DownloadsServerConfig) Handler() http.Handler {
 	fs := http.FileServer(http.Dir(c.TempDir))
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		ext := filepath.Ext(r.URL.Path)
-		if ext == ".tar" || ext == ".zip" {
-			<-c.archivesReady
+		// temporary workaround for the CLI download configuration done in the console operator.
+		// can be dropped when the CLI download configuration is fixed to use "tar.gz" rather than
+		// "tar"
+		if strings.HasSuffix(r.URL.Path, ".tar") {
+			r.URL.Path += ".gz"
+		}
+
+		if strings.HasSuffix(r.URL.Path, ".zip") || strings.HasSuffix(r.URL.Path, ".tar.gz") {
+			select {
+			case <-r.Context().Done():
+				w.Header().Set("Retry-After", "3")
+				http.Error(w, http.StatusText(http.StatusServiceUnavailable), http.StatusServiceUnavailable)
+				return
+			case <-c.archivesReady:
+			}
 		}
 		fs.ServeHTTP(w, r)
 	})
@@ -408,7 +411,10 @@ func (c *DownloadsServerConfig) Handler() http.Handler {
 // setupArtifactsDirectory creates the root HTML file and directories, files and archives for artifacts
 func (artifactsConfig *DownloadsServerConfig) setupArtifactsDirectory() error {
 	// symlink file in the temporary directory that points to the openshift license
-	os.Symlink(pathToOCLicense, filepath.Join(artifactsConfig.TempDir, ocLicenseFile))
+	err := os.Symlink(pathToOCLicense, filepath.Join(artifactsConfig.TempDir, ocLicenseFile))
+	if err != nil {
+		klog.Errorf("can't create symlink to the LICENSE file in %s: %v", artifactsConfig.TempDir, err)
+	}
 
 	// generates content of the root html file and creates directories, files and archives for artifacts
 	content, err := artifactsConfig.generateDirFileContents()
diff --git a/cmd/downloads/config/downloads_config_test.go b/cmd/downloads/config/downloads_config_test.go
index 0c8db247912..e55ed01c3b3 100644
--- a/cmd/downloads/config/downloads_config_test.go
+++ b/cmd/downloads/config/downloads_config_test.go
@@ -3,12 +3,16 @@ package config
 import (
 	"archive/tar"
 	"archive/zip"
+	"compress/gzip"
+	"context"
+	"fmt"
 	"io"
 	"net/http"
 	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
 	"text/template"
 	"time"
@@ -72,7 +76,6 @@ func newTestConfig(t *testing.T, specs []ArtifactSpec) *DownloadsServerConfig {
 	}
 
 	return &DownloadsServerConfig{
-		Port:         "0",
 		Spec:         specs,
 		TempDir:      tempDir,
 		TemplateHTML: tmpl,
@@ -110,16 +113,16 @@ func TestGenerateDirFileContents_RelativeURLs(t *testing.T) {
 	if linux.URL != "amd64/linux/oc" {
 		t.Errorf("expected URL %q, got %q", "amd64/linux/oc", linux.URL)
 	}
-	if linux.TarURL != "amd64/linux/oc.tar" {
-		t.Errorf("expected TarURL %q, got %q", "amd64/linux/oc.tar", linux.TarURL)
+	if linux.TarURL != "amd64/linux/oc.tar.gz" {
+		t.Errorf("expected TarURL %q, got %q", "amd64/linux/oc.tar.gz", linux.TarURL)
 	}
 
 	win := content[2]
 	if win.URL != "amd64/windows/oc.exe" {
 		t.Errorf("expected URL %q, got %q", "amd64/windows/oc.exe", win.URL)
 	}
-	if win.TarURL != "amd64/windows/oc.tar" {
-		t.Errorf("expected TarURL %q, got %q", "amd64/windows/oc.tar", win.TarURL)
+	if win.TarURL != "amd64/windows/oc.tar.gz" {
+		t.Errorf("expected TarURL %q, got %q", "amd64/windows/oc.tar.gz", win.TarURL)
 	}
 	if win.ZipURL != "amd64/windows/oc.zip" {
 		t.Errorf("expected ZipURL %q, got %q", "amd64/windows/oc.zip", win.ZipURL)
@@ -150,20 +153,7 @@ func TestCreateArchivesInBackground(t *testing.T) {
 		basename := filepath.Base(spec.Path)
 		base := filepath.Join(cfg.TempDir, spec.Arch, spec.OperatingSystem, basename)
 
-		tarPath := base + ".tar"
-		if _, err := os.Stat(tarPath); err != nil {
-			t.Errorf("tar archive not found at %s: %v", tarPath, err)
-			continue
-		}
-		f, _ := os.Open(tarPath)
-		tr := tar.NewReader(f)
-		hdr, err := tr.Next()
-		f.Close()
-		if err != nil {
-			t.Errorf("failed to read tar %s: %v", tarPath, err)
-		} else if hdr.Name != basename {
-			t.Errorf("tar entry name = %q, want %q", hdr.Name, basename)
-		}
+		checkTarFile(t, base, basename)
 
 		zipPath := base + ".zip"
 		if _, err := os.Stat(zipPath); err != nil {
@@ -182,6 +172,34 @@ func TestCreateArchivesInBackground(t *testing.T) {
 	}
 }
 
+func checkTarFile(t *testing.T, base, basename string) {
+	tarPath := base + ".tar.gz"
+	if _, err := os.Stat(tarPath); err != nil {
+		t.Errorf("tar archive not found at %s: %v", tarPath, err)
+		return
+	}
+	f, err := os.Open(tarPath)
+	if err != nil {
+		t.Fatalf("failed to open archive at %s: %v", tarPath, err)
+	}
+	defer f.Close()
+
+	gzw, err := gzip.NewReader(f)
+	if err != nil {
+		t.Fatalf("failed to open archive at %s: %v", tarPath, err)
+	}
+	defer gzw.Close()
+
+	tr := tar.NewReader(gzw)
+	hdr, err := tr.Next()
+	if err != nil {
+		t.Errorf("failed to read tar %s: %v", tarPath, err)
+	} else if hdr.Name != basename {
+		t.Errorf("tar entry name = %q, want %q", hdr.Name, basename)
+	}
+
+}
+
 func TestHandler_BlocksUntilArchivesReady(t *testing.T) {
 	tmpDir := t.TempDir()
 	if err := os.WriteFile(filepath.Join(tmpDir, "index.html"), []byte("<html>ok</html>"), 0644); err != nil {
@@ -190,7 +208,7 @@ func TestHandler_BlocksUntilArchivesReady(t *testing.T) {
 	if err := os.MkdirAll(filepath.Join(tmpDir, "amd64", "linux"), 0755); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(tmpDir, "amd64", "linux", "oc.tar"), []byte("archive"), 0644); err != nil {
+	if err := os.WriteFile(filepath.Join(tmpDir, "amd64", "linux", "oc.tar.gz"), []byte("archive"), 0644); err != nil {
 		t.Fatal(err)
 	}
 
@@ -213,7 +231,7 @@ func TestHandler_BlocksUntilArchivesReady(t *testing.T) {
 	t.Run("archive request blocks then succeeds", func(t *testing.T) {
 		done := make(chan int, 1)
 		go func() {
-			req := httptest.NewRequest(http.MethodGet, "/amd64/linux/oc.tar", nil)
+			req := httptest.NewRequest(http.MethodGet, "/amd64/linux/oc.tar.gz", nil)
 			rec := httptest.NewRecorder()
 			handler.ServeHTTP(rec, req)
 			done <- rec.Code
@@ -238,14 +256,14 @@ func TestHandler_BlocksUntilArchivesReady(t *testing.T) {
 	})
 }
 
-func writeTestSpecsFile(t *testing.T, binaryPath string) string {
+func writeTestSpecsFile(t *testing.T, binaryPath string) []byte {
 	t.Helper()
-	specContent := []byte("defaultArtifactsConfig:\n  - arch: amd64\n    operatingSystem: linux\n    path: " + binaryPath + "\n")
-	specFile := filepath.Join(t.TempDir(), "config.yaml")
-	if err := os.WriteFile(specFile, specContent, 0644); err != nil {
-		t.Fatalf("failed to write spec file: %v", err)
-	}
-	return specFile
+	return fmt.Appendf(nil, `defaultArtifactsConfig:
+- arch: amd64
+  operatingSystem: linux
+  path: %s
+`,
+		binaryPath)
 }
 
 func TestNewDownloadsServerConfig_CreatesDirectory(t *testing.T) {
@@ -258,7 +276,7 @@ func TestNewDownloadsServerConfig_CreatesDirectory(t *testing.T) {
 		t.Fatalf("failed to write fake binary: %v", err)
 	}
 
-	cfg, err := NewDownloadsServerConfig(0, writeTestSpecsFile(t, binaryPath))
+	cfg, err := NewDownloadsServerConfig(writeTestSpecsFile(t, binaryPath))
 	if err != nil {
 		t.Fatalf("NewDownloadsServerConfig() error: %v", err)
 	}
@@ -292,7 +310,7 @@ func TestNewDownloadsServerConfig_CleansStaleData(t *testing.T) {
 		t.Fatalf("failed to write fake binary: %v", err)
 	}
 
-	_, err := NewDownloadsServerConfig(0, writeTestSpecsFile(t, binaryPath))
+	_, err := NewDownloadsServerConfig(writeTestSpecsFile(t, binaryPath))
 	if err != nil {
 		t.Fatalf("NewDownloadsServerConfig() error: %v", err)
 	}
@@ -329,7 +347,7 @@ func TestNewDownloadsServerConfig_CleansOldRandomTempDirs(t *testing.T) {
 		t.Fatalf("failed to write fake binary: %v", err)
 	}
 
-	_, err := NewDownloadsServerConfig(0, writeTestSpecsFile(t, binaryPath))
+	_, err := NewDownloadsServerConfig(writeTestSpecsFile(t, binaryPath))
 	if err != nil {
 		t.Fatalf("NewDownloadsServerConfig() error: %v", err)
 	}
@@ -342,31 +360,110 @@ func TestNewDownloadsServerConfig_CleansOldRandomTempDirs(t *testing.T) {
 }
 
 func TestHandler_ServesArchiveImmediatelyWhenReady(t *testing.T) {
+	for _, tc := range []struct {
+		name              string
+		fileName          string
+		requestedFileName string
+	}{
+		{
+			name:              "check download tar.gz",
+			fileName:          "oc.tar.gz",
+			requestedFileName: "oc.tar.gz",
+		},
+		{
+			name:              "check download tar, get tar.gz",
+			fileName:          "oc.tar.gz",
+			requestedFileName: "oc.tar",
+		},
+		{
+			name:              "check download tar.zip",
+			fileName:          "oc.zip",
+			requestedFileName: "oc.zip",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			tmpDir := t.TempDir()
+			dir := filepath.Join(tmpDir, "amd64", "linux")
+			if err := os.MkdirAll(dir, 0755); err != nil {
+				t.Fatal(err)
+			}
+			defer os.RemoveAll(dir)
+
+			archiveContent := []byte("archive-data")
+			if err := os.WriteFile(filepath.Join(dir, tc.fileName), archiveContent, 0644); err != nil {
+				t.Fatal(err)
+			}
+
+			ready := make(chan struct{})
+			close(ready)
+			cfg := &DownloadsServerConfig{
+				TempDir:       tmpDir,
+				archivesReady: ready,
+			}
+
+			req := httptest.NewRequest(http.MethodGet, "/amd64/linux/"+tc.requestedFileName, nil)
+			rec := httptest.NewRecorder()
+			cfg.Handler().ServeHTTP(rec, req)
+
+			if rec.Code != http.StatusOK {
+				t.Errorf("expected 200, got %d", rec.Code)
+			}
+			body, _ := io.ReadAll(rec.Result().Body)
+			if string(body) != string(archiveContent) {
+				t.Errorf("expected body %q, got %q", archiveContent, body)
+			}
+		})
+	}
+}
+
+func TestHandler_ServesArchiveTimeout(t *testing.T) {
 	tmpDir := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(tmpDir, "amd64", "linux"), 0755); err != nil {
+	dir := filepath.Join(tmpDir, "amd64", "linux")
+	if err := os.MkdirAll(dir, 0755); err != nil {
 		t.Fatal(err)
 	}
+	defer os.RemoveAll(dir)
+
 	archiveContent := []byte("archive-data")
-	if err := os.WriteFile(filepath.Join(tmpDir, "amd64", "linux", "oc.tar"), archiveContent, 0644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, "oc.tar.gz"), archiveContent, 0644); err != nil {
 		t.Fatal(err)
 	}
 
 	ready := make(chan struct{})
-	close(ready)
+	once := &sync.Once{}
+	closeFunc := func() {
+		once.Do(func() {
+			close(ready)
+		})
+	}
+	defer closeFunc() // for error case
+
 	cfg := &DownloadsServerConfig{
 		TempDir:       tmpDir,
 		archivesReady: ready,
 	}
 
-	req := httptest.NewRequest(http.MethodGet, "/amd64/linux/oc.tar", nil)
+	ctxBefore, cancelBefore := context.WithTimeout(t.Context(), time.Millisecond*100)
+	defer cancelBefore()
+
+	req := httptest.NewRequestWithContext(ctxBefore, http.MethodGet, "/amd64/linux/oc.tar.gz", nil)
 	rec := httptest.NewRecorder()
 	cfg.Handler().ServeHTTP(rec, req)
 
+	if rec.Code != http.StatusServiceUnavailable {
+		t.Errorf("expected 503, got %d", rec.Code)
+	}
+
+	closeFunc() // make the server ready
+
+	ctxAfter, cancelAfter := context.WithTimeout(t.Context(), time.Millisecond*100)
+	defer cancelAfter()
+
+	req = httptest.NewRequestWithContext(ctxAfter, http.MethodGet, "/amd64/linux/oc.tar.gz", nil)
+	rec = httptest.NewRecorder()
+	cfg.Handler().ServeHTTP(rec, req)
+
 	if rec.Code != http.StatusOK {
 		t.Errorf("expected 200, got %d", rec.Code)
 	}
-	body, _ := io.ReadAll(rec.Result().Body)
-	if string(body) != string(archiveContent) {
-		t.Errorf("expected body %q, got %q", archiveContent, body)
-	}
 }
diff --git a/cmd/downloads/main.go b/cmd/downloads/main.go
index fe50f622acf..14747c04c32 100644
--- a/cmd/downloads/main.go
+++ b/cmd/downloads/main.go
@@ -1,29 +1,39 @@
 package main
 
 import (
+	_ "embed"
 	"flag"
 	"fmt"
-
 	"net/http"
 	"os"
+	"strconv"
+
+	"k8s.io/klog/v2"
 
 	"github.com/openshift/console/cmd/downloads/config"
-	klog "k8s.io/klog/v2"
 )
 
+//go:embed config/defaultArtifactsConfig.yaml
+var downloadConfigBytes []byte
+
 func main() {
 	fs := flag.NewFlagSet("downloads", flag.ExitOnError)
 	klog.InitFlags(fs)
 	defer klog.Flush()
 
-	fPort := fs.Int("port", 8080, "Port number used to start the downloads server.")
-	fPathToArtifactsFileConfig := fs.String("config-path", "/opt/downloads/defaultArtifactsConfig.yaml", "Path to the configuration file of available 'oc' artifacts.")
+	var portArg int
+
+	fs.IntVar(&portArg, "port", 8080, "Port number used to start the downloads server.")
+	// leave it here for backward compatible
+	_ = fs.String("config-path", "", "this flag is deprecated and ignored")
 
 	if err := fs.Parse(os.Args[1:]); err != nil {
 		klog.Fatalf("Failed to parse flags: %v", err)
 		os.Exit(1)
 	}
-	downloadsServerConfig, err := config.NewDownloadsServerConfig(*fPort, *fPathToArtifactsFileConfig)
+	port := strconv.Itoa(portArg)
+
+	downloadsServerConfig, err := config.NewDownloadsServerConfig(downloadConfigBytes)
 	if err != nil {
 		klog.Fatalf("Failed to configure downloads server config: %v", err)
 		os.Exit(1)
@@ -31,13 +41,12 @@ func main() {
 	downloadsServerConfig.CreateArchivesInBackground()
 
 	// Listen for incoming connections
-	klog.Infof("Server started. Listening on http://0.0.0.0:%s", downloadsServerConfig.Port)
+	klog.Infof("Server started. Listening on http://0.0.0.0:%s", port)
 
 	// Serve the files and listen for incoming connections
 	downlsrv := &http.Server{
-		Addr:    fmt.Sprintf("0.0.0.0:%s", downloadsServerConfig.Port),
+		Addr:    fmt.Sprintf("0.0.0.0:%s", port),
 		Handler: downloadsServerConfig.Handler(),
 	}
 	klog.Fatal(downlsrv.ListenAndServe())
-
 }
