Ինչպես ստեղծել մասնավոր Docker ռեեստր Ubuntu 22.04-ում

Այս ձեռնարկը գոյություն ունի ՕՀ-ի այս տարբերակների համար

• Ubuntu 22.04 (Jammy Jellyfish)
• Ubuntu 17.10 (Artful Aardvark)

Այս էջում

1. Նախադրյալներ
2. Քայլ 1 - Կարգավորել Firewall-ը
3. Քայլ 2 - Տեղադրեք Docker-ը և Docker Compose-ը

4. Քայլ 3 - Կարգավորեք Docker Registry-ը

   1. Ստեղծեք օգտվողների գրացուցակներ
   2. Ստեղծեք Amazon S3 Bucket-ը
   3. Ստեղծեք Docker Compose ֆայլ
   4. Կարգավորեք նույնականացումը

5. Քայլ 4 - Տեղադրեք SSL-ը

   1. Պատճենեք Dhparam ֆայլը կոնտեյներով
6. Քայլ 5 - Կարգավորեք Nginx-ը
7. Քայլ 6 - Գործարկել Docker Registry-ը
8. Քայլ 7 - Մուտք գործեք և օգտագործեք Docker ռեեստրը Client Machine-ից
9. Եզրակացություն

Եթե դուք աշխատում եք կազմակերպությունում և ցանկանում եք ձեր Docker պատկերները պահել տանը՝ արագ տեղակայման համար, ապա մասնավոր Docker պահոցը կատարյալ է: Մասնավոր դոկեր ռեգիստր ունենալը թույլ է տալիս ունենալ ձեր պատկերների բաշխման խողովակաշարը և ավելի խիստ վերահսկողություն ունենալ պատկերների պահպանման և բաշխման վրա: Դուք կարող եք ինտեգրել ձեր ռեեստրը ձեր CI/CD համակարգի հետ՝ բարելավելով ձեր աշխատանքային հոսքը:

Այս ձեռնարկը կսովորեցնի ձեզ, թե ինչպես ստեղծել և օգտագործել անձնական Docker ռեեստրը Ubuntu 22.04 սերվերի վրա՝ օգտագործելով Amazon S3-ը որպես պահեստավորման վայր:

Նախադրյալներ

Երկու Linux սերվեր Ubuntu 22.04-ով: Մի սերվերը կգործի որպես ռեեստրի հոսթ, իսկ մյուսը կօգտագործվի որպես հաճախորդ՝ հոսթից հարցումներ ուղարկելու և պատկերներ ստանալու համար:

Գրանցված տիրույթի անուն, որը ցույց է տալիս հյուրընկալող սերվերը: Մենք կօգտագործենք registry.example.com մեր ձեռնարկի համար:

Ոչ արմատային օգտատեր, որն ունի sudo արտոնություններ երկու մեքենաների վրա:

Համոզվեք, որ ամեն ինչ թարմացվում է:

$ sudo apt update
$ sudo apt upgrade

Մի քանի փաթեթներ, որոնք անհրաժեշտ են ձեր համակարգին:

$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Այս փաթեթներից որոշները կարող են արդեն տեղադրված լինել ձեր համակարգում:

Քայլ 1 - Կարգավորել Firewall-ը

Առաջին քայլը firewall-ի կազմաձևումն է: Ubuntu-ն լռելյայն գալիս է ufw-ով (Uncomplicated Firewall):

Ստուգեք, արդյոք firewall-ը աշխատում է:

$ sudo ufw status

Դուք պետք է ստանաք հետևյալ արդյունքը.

Status: inactive

Թույլատրել SSH միացքը, որպեսզի այն միացնելուց հետո firewall-ը չխախտի ընթացիկ կապը:

$ sudo ufw allow OpenSSH

Թույլատրել նաև HTTP և HTTPS պորտերը:

$ sudo ufw allow http
$ sudo ufw allow https

Միացնել Firewall-ը

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Կրկին ստուգեք firewall-ի կարգավիճակը:

$ sudo ufw status

Դուք պետք է տեսնեք նմանատիպ արդյունք:

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Քայլ 2 - Տեղադրեք Docker-ը և Docker Compose-ը

Այս քայլը պահանջվում է ինչպես սերվերի, այնպես էլ հաճախորդի մեքենաների վրա:

Ubuntu 22.04-ը մատակարարվում է Docker-ի ավելի հին տարբերակով: Վերջին տարբերակը տեղադրելու համար նախ ներմուծեք Docker GPG ստեղնը:

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Ստեղծեք Docker պահեստային ֆայլ:

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Թարմացրեք համակարգի պահեստների ցանկը:

$ sudo apt update

Տեղադրեք Docker-ի վերջին տարբերակը:

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Ստուգեք, որ այն աշխատում է:

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2023-04-13 09:37:09 UTC; 3min 47s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 2106 (dockerd)
      Tasks: 7
     Memory: 26.0M
        CPU: 267ms
     CGroup: /system.slice/docker.service
             ??2106 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Լռելյայնորեն, Docker-ը պահանջում է արմատային արտոնություններ: Եթե ցանկանում եք խուսափել sudo-ից ամեն անգամ, երբ գործարկում եք docker հրամանը, ավելացրեք ձեր օգտվողի անունը docker խմբին:

$ sudo usermod -aG docker $(whoami)

Դուք պետք է դուրս գաք սերվերից և նորից մուտք գործեք որպես նույն օգտվող՝ այս փոփոխությունը միացնելու համար կամ օգտագործեք հետևյալ հրամանը:

$ su - ${USER}

Հաստատեք, որ ձեր օգտվողն ավելացված է Docker խմբին:

$ groups
navjot wheel docker

Քայլ 3 - Կարգավորեք Docker Registry-ը

Ստեղծեք օգտվողների գրացուցակներ

Ստեղծեք գրացուցակ ռեեստրի կազմաձևման համար:

$ mkdir ~/docker-registry

Անցեք docker-registry գրացուցակին:

$ cd ~/docker-registry

Ստեղծեք գրացուցակ՝ HTTP նույնականացման գաղտնաբառը, Nginx կազմաձևման ֆայլերը և SSL վկայականները պահելու համար:

$ mkdir auth

Ստեղծեք մեկ այլ գրացուցակ՝ Nginx տեղեկամատյանները պահելու համար:

$ mkdir logs

Ստեղծեք Amazon S3 Bucket-ը

Դուք կարող եք պահպանել ռեեստրի տվյալները և պատկերները ձեր սերվերում կամ օգտագործել ամպային հոսթինգ ծառայություն: Մեր ձեռնարկի համար մենք կօգտագործենք Amazon S3 ամպային ծառայությունը:

Հաջորդ քայլը մի քանի կարևոր կարգավորումներով կազմաձևման ֆայլի կարգավորումն է: Այս կարգավորումները կարող են սահմանվել նաև docker-compose.yml ֆայլում, սակայն առանձին ֆայլ ունենալը շատ ավելի լավ է:

Ստեղծեք դույլ հետևյալ պարամետրերով.

• ACL-ը պետք է անջատված լինի:
• Հանրային մուտքը դեպի դույլ պետք է անջատված լինի:
• Դույլի տարբերակավորումը պետք է անջատված լինի:
• Միացնել Bucket ծածկագրումը Amazon S3-ի կառավարվող բանալիների միջոցով: (SSE-S3)
• Օբյեկտների կողպումը պետք է անջատված լինի:

Ստեղծեք IAM օգտվող հետևյալ քաղաքականությամբ.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetBucketLocation",
        "s3:ListBucketMultipartUploads"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME"
    },
    {
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:DeleteObject",
        "s3:ListMultipartUploadParts",
        "s3:AbortMultipartUpload"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME/*"
    }
  ]
}

Փոխարինեք S3_BUCKET_NAME-ը ձեր S3 դույլի անունով:

Նշեք գաղտնի բանալին, գաղտնի արժեքը և ձեր դույլի դույլի շրջանը, որը հետագայում կօգտագործվի:

Ստեղծեք Docker Compose ֆայլ

Ստեղծեք docker-compose.yml ֆայլը և բացեք այն խմբագրման համար:

$ nano docker-compose.yml

Դրա մեջ տեղադրեք հետևյալ կոդը.

services:
  registry:
    image: registry:2
    restart: always
    environment:
      - REGISTRY_STORAGE=s3
      - REGISTRY_STORAGE_S3_REGION=us-west-2
      - REGISTRY_STORAGE_S3_BUCKET=hf-docker-registry
      - REGISTRY_STORAGE_S3_ENCRYPT=true
      - REGISTRY_STORAGE_S3_CHUNKSIZE=5242880
      - REGISTRY_STORAGE_S3_SECURE=true
      - REGISTRY_STORAGE_S3_ACCESSKEY=AKIA3FIG4NVFNXKQXMSJ
      - REGISTRY_STORAGE_S3_SECRETKEY=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
      - REGISTRY_STORAGE_S3_V4AUTH=true
      - REGISTRY_STORAGE_S3_ROOTDIRECTORY=/image-registry
      - REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR=inmemory
      - REGISTRY_HEALTH_STORAGEDRIVER_ENABLED=false
  nginx:
    image: "nginx:alpine"
    ports:
      - 443:443
    links:
      - registry:registry
    volumes:
      - ./auth:/etc/nginx/conf.d
      - ./auth/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./logs:/var/log/nginx
      - /etc/letsencrypt:/etc/letsencrypt

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ պահանջվում է:

Եկեք անցնենք այն, ինչ մենք ստեղծել ենք մեր կազմման ֆայլում:

Առաջին քայլը Docker ռեեստրի 2-րդ տարբերակի վերջին պատկերը հանգույցից վերցնելն է: Մենք չենք օգտագործում վերջին պիտակը, քանի որ այն կարող է խնդիրներ առաջացնել հիմնական տարբերակի թարմացման դեպքում: 2-ի սահմանումը թույլ է տալիս վերցնել բոլոր 2.x թարմացումները՝ միաժամանակ կանխելով ավտոմատ թարմացումը հաջորդ հիմնական տարբերակին, որը կարող է կտրուկ փոփոխություններ մտցնել:

Ռեեստրի բեռնարկղը միշտ վերագործարկվելու է ձախողման կամ անսպասելի անջատման դեպքում:

Մենք սահմանել ենք շրջակա միջավայրի տարբեր փոփոխականներ Amazon S3 պահեստավորման համար: Եկեք արագ անցնենք դրանց միջով:

• REGISTRY_STORAGE սահմանում է պահեստի տեսակը: Մենք ընտրել ենք s3, քանի որ օգտագործում ենք Amazon S3-ը:
• REGISTRY_STORAGE_S3_REGION սահմանում է ձեր S3 դույլի տարածքը:
• REGISTRY_STORAGE_S3_BUCKET սահմանում է ձեր S3 դույլի անունը:
• REGISTRY_STORAGE_S3_ENCRYPT - սահմանեք այն true, եթե միացրել եք Bucket ծածկագրումը:
• REGISTRY_STORAGE_S3_CHUNKSIZE սահմանում է վերբեռնման մասերի չափը: Այն պետք է լինի ավելի մեծ, քան 5 ՄԲ (5 * 1024 * 1024):
• REGISTRY_STORAGE_S3_SECURE - սահմանեք այն true, եթե պատրաստվում եք օգտագործել HTTPS:
• REGISTRY_STORAGE_S3_ACCESSKEY և REGISTRY_STORAGE_S3_SECRETKEY - Օգտատիրոջ հավատարմագրերը, որոնք դուք վերցրել եք ձեր IAM օգտվողը ստեղծելուց հետո:
• REGISTRY_STORAGE_S3_V4AUTH - սահմանեք այն true, եթե օգտագործում եք AWS վավերացման v4: Եթե սխալներ եք ստանում՝ կապված S3 մուտքի հետ, դրեք այն false-ի վրա:
• REGISTRY_STORAGE_S3_ROOTDIRECTORY - սահմանում է ձեր դույլի արմատային գրացուցակը, որի տակ կպահվեն ձեր ռեեստրի տվյալները:
• REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR - սահմանում է քեշի գտնվելու վայրը: Մեր դեպքում մենք այն պահում ենք հիշողության մեջ։ Կարող եք նաև սահմանել, որ այն օգտագործի Redis-ը:
• REGISTRY_HEALTH_STORAGEDRIVER_ENABLED - Սահմանեք այն false-ի՝ ռեեստրի պահեստի առողջության ստուգման ծառայությունն անջատելու համար: Ռեեստրի հետ կապված վրիպակ կա, որը կարող է խնդիրներ առաջացնել, եթե այն կեղծ չդրեք:

Docker ռեգիստրը հաղորդակցվում է 5000 նավահանգստի միջոցով, ինչը մենք մեր սերվերում ցուցադրել ենք դոկերին:

./auth:/etc/nginx/conf.d քարտեզագրումն ապահովում է, որ Nginx-ի բոլոր կարգավորումները հասանելի են կոնտեյներով:

./auth/nginx.conf:/etc/nginx/nginx.conf:ro քարտեզագրում է Nginx կարգավորումների ֆայլը համակարգից դեպի կոնտեյներ միայն կարդալու ռեժիմով:

./logs:/var/log/nginx թույլ է տալիս մուտք գործել Nginx-ի տեղեկամատյաններ համակարգում՝ քարտեզագրելով կոնտեյների Nginx տեղեկամատյանների գրացուցակը:

Docker ռեեստրի կարգավորումները պահվում են բեռնարկղի /etc/docker/registry/config.yml ֆայլում, և մենք այն քարտեզագրել ենք ընթացիկ պահի config.yml ֆայլում: գրացուցակը, որը մենք կստեղծենք հաջորդ քայլում:

Կարգավորեք նույնականացումը

HTTP նույնականացումը կարգավորելու համար անհրաժեշտ է տեղադրել httpd-tools փաթեթը:

$ sudo apt install apache2-utils -y

Ստեղծեք գաղտնաբառի ֆայլը ~/docker-registry/auth գրացուցակում:

$ htpasswd -Bc ~/docker-registry/auth/nginx.htpasswd user1
New password:
Re-type new password:
Adding password for user user1

-c դրոշը հրահանգում է նոր ֆայլ ստեղծելու հրամանը, իսկ -B դրոշը պետք է օգտագործի Docker-ի կողմից աջակցվող bcrypt ալգորիթմը: Փոխարինեք user1 ձեր ընտրած օգտվողի անունով:

Եթե ցանկանում եք ավելացնել ավելի շատ օգտվողներ, նորից գործարկեք հրամանը, բայց առանց -c դրոշի:

$ htpasswd -B ~/docker-registry/auth/registry.password user2

Այժմ ֆայլը կփոխանցվի ռեեստրի կոնտեյներով՝ նույնականացման համար:

Քայլ 4 - Տեղադրեք SSL-ը

SSL վկայագիր ստեղծելու համար մենք պետք է տեղադրենք Certbot-ը: Կարող եք կա՛մ տեղադրել Certbot-ը՝ օգտագործելով Ubuntu-ի պահոցը, կա՛մ ձեռք բերել վերջին տարբերակը՝ օգտագործելով Snapd գործիքը: Մենք կօգտագործենք Snapd տարբերակը:

Ubuntu 22.04-ը գալիս է լռելյայն տեղադրված Snapd-ով: Գործարկեք հետևյալ հրամանները՝ համոզվելու համար, որ Snapd-ի ձեր տարբերակը արդիական է:

$ sudo snap install core && sudo snap refresh core

Տեղադրեք Certbot-ը:

$ sudo snap install --classic certbot

Օգտագործեք հետևյալ հրամանը՝ համոզվելու համար, որ Certbot հրամանը կարող է գործարկվել՝ ստեղծելով խորհրդանշական հղում դեպի /usr/bin գրացուցակը:

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Գործարկեք հետևյալ հրամանը՝ SSL վկայական ստեղծելու համար:

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email  -d registry.example.com

Վերոնշյալ հրամանը վկայական կներբեռնի ձեր սերվերի /etc/letsencrypt/live/registry.example.com գրացուցակում:

Ստեղծեք Diffie-Hellman խումբ վկայագիր:

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Ստուգեք Certbot-ի նորացման ժամանակացույցի ծառայությունը:

$ sudo systemctl list-timers

Դուք կգտնեք snap.certbot.renew.service որպես սպասարկվող ծառայություններից մեկը:

NEXT                        LEFT          LAST                        PASSED        UNIT                      ACTIVATES
.....
Sun 2023-04-14 00:00:00 UTC 19min left    Sat 2023-02-25 18:04:05 UTC n/a          snap.certbot.renew.timer  snap.certbot.renew.service
Sun 2023-04-14 00:00:20 UTC 19min left    Sat 2023-02-25 10:49:23 UTC 14h ago      apt-daily-upgrade.timer   apt-daily-upgrade.service
Sun 2023-04-14 00:44:06 UTC 3h 22min left Sat 2023-02-25 20:58:06 UTC 7h ago       apt-daily.timer           apt-daily.service

Կատարեք գործընթացի չոր գործարկում՝ ստուգելու, թե արդյոք SSL-ի նորացումը լավ է աշխատում:

$ sudo certbot renew --dry-run

Եթե սխալներ չեք տեսնում, ամեն ինչ պատրաստ է: Ձեր վկայականը ինքնաբերաբար կերկարաձգվի:

Պատճենեք Dhparam ֆայլը կոնտեյներով

Պատճենեք Diffie-Hellman group վկայագիրը ~/docker-registry/auth գրացուցակում, որը կփոխանցվի կոնտեյների մեջ:

$ sudo cp /etc/ssl/certs/dhparam.pem ~/docker-registry/auth

Քայլ 5 - Կարգավորեք Nginx-ը

Հաջորդ քայլը ներառում է Nginx սերվերի կազմաձևումը որպես Docker ռեեստրի սերվերի ճակատային վստահված անձ: Docker ռեեստրը գալիս է ներկառուցված սերվերով, որը գործում է 5000 նավահանգստում: Մենք այն կդնենք Nginx-ի հետևում:

Ստեղծեք և բացեք ֆայլը ~/docker-registry/auth/nginx.conf խմբագրման համար:

$ sudo nano ~/docker-registry/auth/nginx.conf

Դրա մեջ տեղադրեք հետևյալ կոդը.

events {
    worker_connections  1024;
}

http {

  upstream docker-registry {
    server registry:5000;
  }

  ## Set a variable to help us decide if we need to add the
  ## 'Docker-Distribution-Api-Version' header.
  ## The registry always sets this header.
  ## In the case of nginx performing auth, the header is unset
  ## since nginx is auth-ing before proxying.
  map $upstream_http_docker_distribution_api_version $docker_distribution_api_version {
    '' 'registry/2.0';
  }

  server {
    listen 443 ssl http2;
    server_name registry.example.com;

    # SSL
    ssl_certificate /etc/letsencrypt/live/registry.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/registry.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/registry.example.com/chain.pem;

    access_log  /var/log/nginx/registry.access.log;
    error_log   /var/log/nginx/registry.error.log;

    # Recommendations from https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers on;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/nginx/conf.d/dhparam.pem;
    resolver 8.8.8.8;

    # disable any limits to avoid HTTP 413 for large image uploads
    client_max_body_size 0;

    # required to avoid HTTP 411: see Issue #1486 (https://github.com/moby/moby/issues/1486)
    chunked_transfer_encoding on;

    location /v2/ {
      # Do not allow connections from docker 1.5 and earlier
      # docker pre-1.6.0 did not properly set the user agent on ping, catch "Go *" user agents
      if ($http_user_agent ~ "^(docker\/1\.(3|4|5(?!\.[0-9]-dev))|Go ).*$" ) {
        return 404;
      }

      # To add basic authentication to v2 use auth_basic setting.
      auth_basic "Registry realm";
      auth_basic_user_file /etc/nginx/conf.d/nginx.htpasswd;

      ## If $docker_distribution_api_version is empty, the header is not added.
      ## See the map directive above where this variable is defined.
      add_header 'Docker-Distribution-Api-Version' $docker_distribution_api_version always;

      proxy_pass                          http://docker-registry;
      proxy_set_header  Host              $http_host;   # required for docker client's sake
      proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
      proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
      proxy_set_header  X-Forwarded-Proto $scheme;
      proxy_read_timeout                  900;
    }
  }
}

Պահպանեք ֆայլը՝ սեղմելով Ctrl + X և մուտքագրելով Y, երբ հուշում են ավարտելուց հետո:

Քայլ 6 - Գործարկել Docker Registry-ը

Անցեք Docker Registry-ի գրացուցակին:

$ cd ~/docker-registry

Գործարկել դոկերի կոնտեյները:

$ docker compose up -d

Ստուգեք բեռնարկղերի կարգավիճակը:

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED              STATUS              PORTS                                      NAMES
3328b7e36bb2   nginx:alpine   "/docker-entrypoint.…"   About a minute ago   Up 3 seconds        80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   docker-registry-nginx-1
bf7cdfc0e013   registry:2     "/entrypoint.sh /etc…"   About a minute ago   Up About a minute   5000/tcp                                 docker-registry-registry-1

Մուտք գործեք Docker ռեգիստր:

$ docker login -u=user1 -p=password https://registry.example.com

Դուք կստանաք հետևյալ արդյունքը.

WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /home/username/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

Կարող եք նաև բացել https://registry.example.com/v2/ URL-ը ձեր բրաուզերում, և այն կպահանջի օգտվողի անուն և գաղտնաբառ: Դուք պետք է տեսնեք դատարկ էջ, որի վրա կա {}:

Դուք կարող եք ստուգել URL-ը տերմինալի վրա՝ օգտագործելով curl:

$ curl -u user1 -X GET https://registry.example.com/v2/
Enter host password for user 'user1':
{}

Ներբեռնեք վերջին Ubuntu docker պատկերը:

$ docker pull ubuntu:latest

Նշեք այս նկարը մասնավոր ռեգիստրի համար:

$ docker tag ubuntu:latest registry.example.com/ubuntu2204

Հրել պատկերը գրանցամատյանում:

$ docker push registry.example.com/ubuntu2204

Ստուգեք՝ արդյոք մղումը հաջող է եղել:

$ curl -u user1 -X GET https://registry.example.com/v2/_catalog
Enter host password for user 'user1':
{"repositories":["ubuntu2204"]}

Մուտքագրեք ձեր Nginx վավերացման գաղտնաբառը, երբ ձեզ հուշեն, և կտեսնեք ռեեստրի միջոցով հասանելի պահեստների ցանկը:

Դուրս եկեք՝ օգտագործելով տերմինալը՝ հավատարմագրերը մաքրելու համար:

$ docker logout https://registry.example.com
Removing login credentials for registry.example.com

Ստուգեք Docker պատկերների ցանկը, որոնք ներկայումս հասանելի են օգտագործման համար:

$ docker images
REPOSITORY                            TAG       IMAGE ID       CREATED       SIZE
registry                             2         8db46f9d7550   2 weeks ago   24.2MB
nginx                                alpine    8e75cbc5b25c   2 weeks ago   41MB
ubuntu                               latest    08d22c0ceb15   5 weeks ago   77.8MB
registry.example.com/ubuntu2204      latest    08d22c0ceb15   5 weeks ago   77.8MB

Քայլ 7 - Մուտք գործեք և օգտագործեք Docker ռեեստրը Client Machine-ից

Մուտք գործեք ձեր հաճախորդ-սերվեր: Քայլ 1-ում մենք տեղադրեցինք Docker-ը հաճախորդի մեքենայի վրա:

Մուտք գործեք անձնական Docker ռեգիստր հաճախորդի մեքենայից:

$ docker login -u=user1 -p=password https://registry.example.com

Քաշեք Ubuntu-ի պատկերը ռեեստրից:

$ docker pull registry.example.com/ubuntu2204

Թվարկեք ձեր հաճախորդի մեքենայի բոլոր պատկերները:

$ docker images
REPOSITORY                        TAG        IMAGE ID       CREATED         SIZE
registry.example.com/ubuntu2204   latest     08d22c0ceb15   5 weeks ago   77.8MB

Ստեղծեք և գործարկեք կոնտեյներ՝ օգտագործելով ներբեռնված պատկերը:

$ docker run -it registry.example.com/ubuntu2204 /bin/bash

Դուք մուտք կգործեք Ubuntu կոնտեյների ներսում գտնվող Shell:

root@647899f255db:

Գործարկեք հետևյալ հրամանը՝ Linux-ի տարբերակը ստուգելու համար։

root@a2da49fdbea9$ cat /etc/os-release
PRETTY_NAME="Ubuntu 22.04.2 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
VERSION="22.04.2 LTS (Jammy Jellyfish)"
VERSION_CODENAME=jammy
ID=ubuntu
ID_LIKE=debian
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
UBUNTU_CODENAME=jammy

Այժմ դուք կարող եք սկսել օգտագործել ձեր Docker ռեեստրը ձեր հաճախորդի մեքենաներից:

Եզրակացություն

Սա ավարտում է մեր ձեռնարկը Ubuntu 22.04 սերվերի վրա անձնական Docker ռեեստրի ստեղծման վերաբերյալ, որն օգտագործում է Amazon S3-ը որպես պահեստ: Եթե ունեք հարցեր, տեղադրեք դրանք ստորև ներկայացված մեկնաբանություններում: