Bir Docker Portunu Nasıl Dışa Açarsınız

Docker kapsayıcılarıyla çalışırken karşılaştığım en kritik konulardan biri, kapsayıcılar ile dış dünya arasında ağ iletişimini etkinleştirmektir. Doğru bağlantı noktası yapılandırması olmadan, kapsayıcılı uygulamalar yalıtılmış ve erişilemez kalır. Bu yazıda, kapsayıcı tabanlı uygulamalarla çalışan herkes için temel bir beceri olan Docker bağlantı noktalarını dışa açma sürecini adım adım anlatacağım.

Bu kılavuz, kapsayıcılı uygulamalarını kullanıcıların, diğer hizmetlerin veya harici sistemlerin erişimine açması gereken yazılım geliştiricileri, DevOps mühendisleri ve BT profesyonelleri için özel olarak hazırlanmıştır. Bir kapsayıcı içinde bir web sunucusu, API veya veritabanı dağıtıyor olun, bağlantı noktalarını dışa açmayı anlamak, işlevsel Docker tabanlı sistemler kurmak için şarttır.

Yazının sonunda, Docker ağ yapısının nasıl çalıştığını, bağlantı noktalarını dışa açmanın farklı yöntemlerini ve bu kavramları kendi projelerinizde uygulamak için pratik teknikleri net bir şekilde kavramış olacaksınız.

Docker’a yeniyseniz, Introduction to Docker, Containerization and Virtualization with Docker and Kubernetes, Intermediate Docker veya Containerization and Virtualization Concepts gibi kurslarımızdan birini almayı düşünebilirsiniz.

Docker’da Bir Bağlantı Noktasını Dışa Açmak Nedir?

Teknik ayrıntılara girmeden önce, Docker ekosisteminde bağlantı noktası dışa açmanın ne anlama geldiğini anlamak önemlidir.

Kapsayıcı ağ yalıtımı ilkeleri

Docker kapsayıcıları, çekirdek bir ilke olarak yalıtım gözetilerek tasarlanmıştır. Bu yalıtım, ad alanları (namespaces) ve cgroups gibi Linux çekirdek özellikleri sayesinde sağlanır. Ad alanları, süreç yalıtımı sunarak bir kapsayıcı içindeki süreçlerin diğer kapsayıcılardaki veya ana sistemdeki süreçleri görmesini ya da onlarla etkileşime girmesini engeller. Cgroups ise kaynak tahsisini kontrol eder; bir kapsayıcının ne kadar CPU, bellek ve diğer kaynakları kullanabileceğini sınırlar.

Ağ açısından bakıldığında, her kapsayıcı varsayılan olarak bir sanal Ethernet arayüzü (veth çifti) ile birlikte kendi ağ ad alanını alır. Bu arayüz, varsayılan olarak bir Docker köprü ağına bağlanır; bu da kapsayıcılar arası iletişime olanak tanırken ana makine ağından yalıtımı sürdürür. Bunu, her kapsayıcının dış dünyaya görünmeyen kendine ait özel bir ağ adresi olması gibi düşünebilirsiniz.

Varsayılan yapılandırmada bir Docker kapsayıcısı tamamen kum havuzu (sandbox) içindedir. İçeride çalışan hizmetler birbirleriyle iletişim kurabilir, ancak kapsayıcının dışından, hatta ana makineden bile erişilemezler. İşte bu noktada bağlantı noktalarını dışa açma gerekliliği ortaya çıkar.

Expose ve publish: anlamsal ayrım

Docker bağlantı noktası yapılandırmasıyla çalışırken, birbiriyle ilişkili ancak farklı iki kavramla karşılaşırsınız: bağlantı noktalarını dışa açma (expose) ve yayınlama (publish).

Bağlantı noktalarını dışa açma (expose) esasen bir dokümantasyon özelliğidir. Docker’da bir bağlantı noktasını dışa açtığınızda, kapsayıcı imgenize, kapsayıcılı uygulamanın belirli bağlantı noktalarını dinlediğini belirten meta veriler eklersiniz. 

Ancak bir bağlantı noktasını dışa açmak, onu kapsayıcının dışından erişilebilir kılmaz. Bu, imgenizi kullananlar için bir dokümantasyon işlevi görür.

Bağlantı noktalarını yayınlama (publish) ise hizmetlerinizi gerçekten dış dünyaya açar. Yayınlama, ana makinedeki bir bağlantı noktası ile kapsayıcı içindeki bir bağlantı noktası arasında eşleme (mapping) oluşturur. Bir bağlantı noktasını yayınladığınızda Docker, belirtilen ana makine bağlantı noktasından gelen trafiği karşılık gelen kapsayıcı bağlantı noktasına yönlendirmek üzere ana makine ağını yapılandırır.

Hangi yaklaşımı ne zaman kullanmalısınız?

• Uygulamanızın hangi bağlantı noktalarını kullandığını belgelemek için, başka Docker kullanıcılarının kullanacağı imgeler oluştururken expose kullanın.
• Kapsayıcınız içinde çalışan hizmetlere ana makine dahil harici sistemlerin erişmesi gerektiğinde publish kullanın.
• Özellikle üretim ortamlarında, tam dokümantasyon ve işlevsellik için her ikisini birlikte kullanın.

Docker Bağlantı Noktaları Nasıl Dışa Açılır

Artık kavramları anladığımıza göre, farklı bağlamlarda Docker bağlantı noktalarını dışa açmanın pratik yönlerine bakalım.

Dockerfile bildirim stratejileri

Bir bağlantı noktasını dışa açmanın en temel yolu, Dockerfile içinde EXPOSE yönergesini kullanmaktır. Bu, kapsayıcının kullanmak üzere tasarlandığı bağlantı noktalarını bildirir.

FROM my-image:latest
EXPOSE 80
EXPOSE 443Altyapı:

Bu örnekte, kapsayıcının HTTP (Hypertext Transfer Protocol) ve HTTPS (Hypertext Transfer Protocol Secure) trafiği için standart olan 80 ve 443 bağlantı noktalarını kullanacağını belirttim. Bunları tek bir yönergede birleştirebilirsiniz:

EXPOSE 80 443Altyapı:

Bağlantı noktalarını belirtirken, uygulamanız belirli bir protokol kullanıyorsa protokolü de (TCP - Transmission Control Protocol veya UDP - User Datagram Protocol) eklemek iyi bir uygulamadır:

EXPOSE 53/udp
EXPOSE 80/tcpAltyapı:

Herhangi bir protokol belirtilmezse varsayılan olarak TCP kabul edilir. Bu, çoğu web uygulaması için uygundur ancak DNS (Domain Name System) veya oyun sunucuları gibi hizmetler sıklıkla UDP gerektirir.

Güvenlik açısından, yalnızca uygulamanızın gerçekten ihtiyaç duyduğu bağlantı noktalarını dışa açmanızı öneririm. Dışa açılan her bağlantı noktası potansiyel bir saldırı yüzeyi oluşturur; bu nedenle dışa açılan bağlantı noktalarının sayısını en aza indirmek, asgari ayrıcalık ilkesine uygun olacaktır.

Çalışma zamanında bağlantı noktası yönetimi

EXPOSE yönergesi kapsayıcının kullandığı bağlantı noktalarını belgelese de, bu bağlantı noktalarını ana makineden veya diğer makinelerden erişilebilir kılmak için kapsayıcıyı çalıştırırken bunları yayınlamanız gerekir.

Bir kapsayıcı bağlantı noktasını belirli bir ana makine bağlantı noktasına açıkça bağlama şekli şöyledir:

docker run -p 8081:80 my-imageAltyapı:

-p (veya --publish) bayrağı, kapsayıcıdaki tek bir bağlantı noktasını veya bağlantı noktası aralığını ana makineye bağlamanıza olanak tanır.

Bu komut, kapsayıcı içindeki 80 numaralı bağlantı noktasını ana makinedeki 8081’e eşler. Bu komutu çalıştırdıktan sonra tarayıcınızda http://localhost:8081 adresine giderek web sunucusuna erişebilirsiniz.

Geliştirme sırasında kolaylık olması için Docker, dışa açılmış tüm bağlantı noktalarını ana makinede rastgele yüksek numaralı bağlantı noktalarına otomatik olarak yayınlayan -P (büyük P) veya --publish-all bayrağını sağlar:

docker run -P my-imageAltyapı:

Hangi ana makine bağlantı noktalarının atandığını bulmak için docker ps komutunu kullanabilirim:

docker psAltyapı:

Çıktı şöyle görünecektir:

CONTAINER ID   IMAGE  COMMAND    CREATED  STATUS  PORTS                                  NAMES
a7c53d9413bf   image  "/docker-.…"  10 s ago   Up 9 s    0.0.0.0:49153->80/tcp, :::49153->80/tcp   wizardlAltyapı:

Burada, kapsayıcı içindeki 80 numaralı bağlantı noktası ana makinede 49153’e eşlenmiştir.

Hem TCP hem de UDP’yi aynı bağlantı noktasında kullanan hizmetlerle (DNS sunucuları gibi) çalışırken, yayınlarken protokolü belirtmeniz gerekir:

docker run -p 53:53/tcp -p 53:53/udp dns-serverAltyapı:

Docker Compose orkestrasyonu

Birden çok kapsayıcıdan oluşan uygulamalar için Docker Compose, ağ ve bağlantı noktası yapılandırmalarını yönetmek için daha kolay bir yol sunar.

Bir Docker Compose YAML dosyasında, her hizmet için ports anahtarı altında bağlantı noktası eşlemelerini belirtebilirsiniz:

services:
  web:
    image: my-image
    ports:
      - "8081:80"
      - "443:443"
  api:
    build: ./api
    ports:
      - "3000:3000"Altyapı:

Docker Compose, ports ve expose arasında önemli bir ayrım yapar. ports bölümü dışarıdan erişilebilen yayınlanmış bağlantı noktası eşlemeleri oluştururken, expose yalnızca aynı Compose ağı içindeki bağlı hizmetlere bağlantı noktalarını sunar:

services:
  web:
    image: my-image
    ports:
      - "8081:80"
  database:
    image: postgres
    expose:
      - "5432"Altyapı:

Bu örnekte, web hizmetine ana makineden 8081 portundan erişilebilirken, PostgreSQL veritabanına yalnızca Compose dosyasındaki diğer hizmetler erişebilir; ana makineden doğrudan erişilemez.

Özellikle farklı ortamlar arasında esneklik için, bağlantı noktası eşlemelerinde ortam değişkenleri kullanabilirim:

services:
  web:
    image: my-image
    ports:
      - "${WEB_PORT:-8081}:80"Altyapı:

Bu söz dizimi, ortam değişkeni (WEB_PORT) ile ana makine bağlantı noktasını belirtmeme olanak tanır; ayarlanmamışsa varsayılan olarak 8081 kullanılır.

Docker Bağlantı Noktalarını Dışa Açma - Uygulamalı Örnek

Bir veritabanı arka ucu olan bir web uygulaması için Docker bağlantı noktalarını dışa açmanın tam bir örneğini birlikte inceleyelim.

Python Flask API hizmeti ve bir PostgreSQL veritabanından oluşan basit bir web uygulaması geliştirdiğimizi hayal edin. API hizmeti 5000 portunda dinler ve PostgreSQL varsayılan 5432 portunu kullanır.

Basit Flask uygulamamızın (app.py) şu şekilde göründüğünü varsayalım. Bu uygulama bir myapp veritabanı oluşturur ve veritabanında bu tablo oluşturulduktan sonra items tablosundan verileri çeker.

from flask import Flask, jsonify
import os
import psycopg2

app = Flask(__name__)

# Database connection parameters from environment variables
DB_HOST = os.environ.get('DB_HOST', 'db')
DB_NAME = os.environ.get('DB_NAME', 'myapp')
DB_USER = os.environ.get('DB_USER', 'postgres')
DB_PASS = os.environ.get('DB_PASSWORD', 'postgres')

@app.route('/')
def index():
    return jsonify({'message': 'API is running'})

@app.route('/items')
def get_items():
    # Connect to the PostgreSQL database
    conn = psycopg2.connect(
        host=DB_HOST,
        database=DB_NAME,
        user=DB_USER,
        password=DB_PASS
    )
    
    # Create a cursor and execute a query
    cur = conn.cursor()
    cur.execute('SELECT id, name FROM items')
    
    # Fetch results and format as list of dictionaries
    items = [{'id': row[0], 'name': row[1]} for row in cur.fetchall()]
    
    # Close connections
    cur.close()
    conn.close()
    
    return jsonify(items)

if __name__ == '__main__':
    # Run the Flask app, binding to all interfaces (important for Docker)
    app.run(host='0.0.0.0', port=5000)Altyapı:

Ardından, requirements.txt dosyamızı oluşturacağım:

flask
psycopg2-binaryAltyapı:

Şimdi Python API hizmetimiz için bir Dockerfile oluşturmam gerekiyor:

FROM python:3.9-slim
WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose the port Flask runs on
EXPOSE 5000

# Command to run the application
CMD ["python", "app.py"]Altyapı:

Son olarak, her iki hizmeti orkestre etmek için bir Docker Compose dosyası oluşturacağım:

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
      tags:
        - "my-custom-image:latest"
    container_name: my-custom-api
    ports:
      - "5000:5000"
    environment:
      - DB_HOST=db
      - DB_NAME=myapp
      - DB_USER=postgres
      - DB_PASSWORD=postgres
    depends_on:
      - db
  
  db:
    container_name: my-custom-db
    image: postgres:13
    expose:
      - "5432"
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:Altyapı:

Bu yapılandırmada:

1. API hizmeti Dockerfile’dan derlenir ve 5000 portunu yayınlar; böylece ana makineden erişilebilir hale gelir.
2. PostgreSQL hizmeti 5432 portunu dışa açar ancak yayınlamaz; böylece yalnızca Compose ağı içindeki diğer hizmetler tarafından erişilebilir olur.
3. API hizmeti, ana makine adı db (hizmet adı) ve 5432 portunu kullanarak veritabanına erişebilir.

Bu uygulamayı çalıştırmak için şunu kullanın:

docker-compose upAltyapı:

Artık API’ye http://localhost:5000 adresinden erişebilirim; ancak PostgreSQL örneğine Docker ağı dışından doğrudan erişilemez; bu da veritabanı hizmetleri için iyi bir güvenlik uygulamasıdır. Ancak çalışan kapsayıcıdan PostgreSQL’e erişebilirsiniz:

docker compose exec db psql -U postgres -d myappAltyapı:

Bu komut PostgreSQL CLI’a erişir; burada veritabanını görüntüleyebilir ve bir items tablosu oluşturabilirsiniz. Oluşturulduktan sonra verileri http://localhost:5000/items adresinde görebilirim.

Birden fazla Docker bağlantı noktasını nasıl dışa açarım

Python uygulamamın birden fazla bağlantı noktasını dışa açması gerekiyorsa, bunların hepsini Dockerfile’da belirtebilirim:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000 8081 9090
CMD ["python", "app.py"]Altyapı:

Bu Dockerfile şunları dışa açar:

• Ana Flask uygulaması için 5000 portu (şu anda aktif)
• Olası bir izleme panosu için 8081 portu 
• Gelecekteki bir hata ayıklama arayüzü için 9090 portu

Dockerfile’da 8081 ve 9090 bağlantı noktalarını dokümantasyon amaçlı olarak dışa açmış olsam da, mevcut Flask uygulamam yalnızca 5000 portunu dinlemek üzere yapılandırılmıştır. Ek dışa açılan bağlantı noktaları gelecekte hangi işlevlerin uygulanabileceğini işaret eder.

Dışa açılmış bağlantı noktaları nasıl yayınlanır

Bir Dockerfile’da dışa açılan bağlantı noktalarını yayınlamak için, kapsayıcıyı çalıştırırken -p veya -P bayrağını kullanırım:

docker run -p 8081:5000  my-custom-imageAltyapı:

Bu, kapsayıcıdaki (Dockerfile’da dışa açılan ve Flask’ın dinlediği) 5000 portunu ana makinede 8081 portuna eşler. Bu komutu çalıştırdıktan sonra tarayıcımda http://localhost:8081 adresine giderek Flask uygulamama erişebilirim.

Ayrıca -P bayrağını kullanarak dışa açılmış tüm bağlantı noktalarını ana makinede rastgele bağlantı noktalarına otomatik olarak yayınlayabilirim:

docker run -P my-custom-imageAltyapı:

Hangi bağlantı noktalarının yayınlandığını kontrol etmek için şunları kullanabilirim:

docker psAltyapı:

Daha ayrıntılı bilgi için şunu kullanabilirim:

docker port [container_id]Altyapı:

5000/tcp -> 0.0.0.0:32768
8081/tcp -> 0.0.0.0:32769
9090/tcp -> 0.0.0.0:32770Altyapı:

Bu komut, belirli bir kapsayıcı için tüm bağlantı noktası eşlemelerini gösterir. Örneğin, Flask uygulamam yalnızca 5000 portunu dinliyor olsa da Dockerfile’da birden fazla bağlantı noktasını dışa açmışsam, Docker port bana hangi ana makine bağlantı noktalarının hangi kapsayıcı bağlantı noktalarına eşlendiğini tam olarak gösterecektir. Dolayısıyla, 5000 portu 32768’e eşlenmişse Flask uygulamama http://localhost:32768 adresinden erişebilirim.

Teşhis ve Sorun Giderme Teknikleri

Dikkatli yapılandırmaya rağmen Docker bağlantı noktası eşlemelerinde sorunlar ortaya çıkabilir. Yaygın problemleri teşhis etmek ve çözmek için kullandığım bazı teknikler aşağıdadır.

Bağlantı noktası eşlemesini inceleme

Bağlantı noktasıyla ilgili sorunları teşhis etmenin ilk adımı, eşlemelerin doğru kurulduğunu doğrulamaktır. Şu komutları kullanırım:

Bağlantı noktası eşlemeleriyle çalışan tüm kapsayıcıları listeleyin:

docker psAltyapı:

Belirli bir kapsayıcı hakkında ayrıntılı bilgi alın:

docker inspect [container_id]Altyapı:

Belirli bir kapsayıcı için bağlantı noktası eşlemelerini kontrol edin:

docker port [container_id]Altyapı:

docker inspect komutu, ağ ayarları da dahil olmak üzere ayrıntılı bilgi sağlar. Ağla ilgili ayrıntılara odaklanmak için şunu kullanın:

docker inspect --format='{{json .NetworkSettings.Ports}}' [container_id] | jqAltyapı:

Daha derin trafik analizi yapmanız gerekirse, tcpdump ve netstat gibi araçlar çok yararlı olabilir. Öncelikle bunların kapsayıcı içinde kurulu olduğundan emin olun. Kapsayıcı bu araçları içermiyorsa, aşağıdaki komutu çalıştırarak kurabilirsiniz:

docker exec -u root -it f5c6cac71492 bash -c "apt-get update && apt-get install -y net-tools tcpdump"Altyapı:

Uygulamanın kapsayıcı içinde hangi bağlantı noktalarını dinlediğini görmek için:

docker exec -it [container_id] netstat -tulnAltyapı:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:5000            0.0.0.0:*               LISTEN
tcp        0      0 127.0.0.11:42265        0.0.0.0:*               LISTEN
udp        0      0 127.0.0.11:34267        0.0.0.0:*Altyapı:

Bu çıktı örneğin Flask uygulamasının tüm arayüzlerde 5000 portunu dinlediğini gösterir.

Kapsayıcının ana ağ arayüzündeki (genellikle eth0) gelen ve giden trafiği izlemek için:

docker exec -it [container_id] tcpdump -i eth0Altyapı:

listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytesAltyapı:

Bu komut, trafiği izleyip isteklerin kapsayıcıya ulaşıp ulaşmadığını veya paketlerin düşürülüp düşürülmediğini ya da yanlış yönlendirilip yönlendirilmediğini tespit etmenizi sağlar.

Iptables kural analizi

Docker, Ağ Adresi Çevirisi’ni (NAT) yönetmek ve ana makine ile kapsayıcılar arasındaki trafik akışını kontrol etmek için iptables’ı kullanır. Ana makine bağlantı noktalarını uygun kapsayıcı IP’lerine ve bağlantı noktalarına yönlendirmek için kuralları otomatik olarak ekler; böylece kapsayıcılı hizmetlere kesintisiz erişim sağlanır.

Yerel Linux ana makinelerinde, bu kuralları şu gibi komutlarla inceleyebilirsiniz:

sudo iptables -t nat -L DOCKER -n -vAltyapı:

Bu komut, belirli ana makine bağlantı noktalarındaki gelen trafiğin Docker tarafından kapsayıcı uç noktalarına nasıl yönlendirildiğini gösterir. Daha önceki Docker Compose dosyasına göre iletilen bağlantı noktalarını göreceksiniz:

Chain DOCKER (2 references)
 pkts bytes target     prot opt in     out     source               destination
   50  3000 RETURN     all  --  docker0 *       0.0.0.0/0            0.0.0.0/0
  100  6000 RETURN     all  --  br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0
  500 30000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:5000 to:172.18.0.2:5000
  400 24000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:8081 to:172.18.0.2:5000
  300 18000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:9090 to:172.18.0.2:5000Altyapı:

Burada:

• DNAT kuralları, trafiği ana makineden kapsayıcıya yeniden yönlendirir.
• RETURN kuralları, dahili Docker ağı trafiğinin doğru yönlendirilmesini sağlar.

Ancak ortamınıza bağlı olarak (örneğin Windows üzerinde Docker Desktop veya WSL2), Docker bağlantı noktası yönlendirmesini farklı şekilde ele alabilir ve iptables kuralları sistem içinde görünmez veya değiştirilemez olabilir. Bu durumda, bağlantı noktası yönlendirmesini aşağıdaki komutla kontrol edebilirsiniz:

sudo ss -tulnpAltyapı:

Netid    State       Recv-Q      Send-Q            Local Address:Port         Peer Address:Port 
tcp        LISTEN     0                 4096                                          *:5000           	        *:*           
tcp        LISTEN     0                 4096                          		   *:8081                               *:*    
tcp        LISTEN     0                 4096                          		   *:9090                              *:*    Altyapı:

Sorun giderme ipuçları:

• docker ps ve docker port [container] ile bağlantı noktası eşlemelerini doğrulayın.
• Ana makine güvenlik duvarının veya güvenlik yazılımının bağlantı noktalarını engelleyip engellemediğini kontrol edin.
• Uygulamanızın ağ davranışını doğrulamak için kapsayıcı günlüklerini ve netstat, tcpdump gibi ağ araçlarını kullanın.

Sonuç

Docker bağlantı noktalarını dışa açmak, kapsayıcı yalıtımı ile pratik kullanılabilirlik arasındaki boşluğu kapatan temel bir beceridir. Bu yazı boyunca Docker’ın ağ modeli nasıl çalışır, bağlantı noktalarını dışa açma ve yayınlama arasındaki fark nedir açıkladım ve çeşitli senaryolar için pratik örnekler sundum.

Şu önemli noktaları aklınızda tutun:

• EXPOSE’u Dockerfile’larda uygulamanızın hangi bağlantı noktalarını kullandığını belgelemek için kullanın
• Bu bağlantı noktalarını dışarıdan erişilebilir kılmak için kapsayıcıları çalıştırırken -p veya -P kullanın
• Karmaşık çoklu kapsayıcı uygulamaları yönetmek için Docker Compose’tan yararlanın
• Sorunlar ortaya çıktığında teşhis araçlarını kullanarak sorun giderin

Bu kavram ve tekniklerde ustalaşmak, hem dahili olarak hem de dış dünya ile etkili şekilde iletişim kuran daha sağlam kapsayıcılı uygulamalar tasarlamanızı sağlar. İster basit bir web uygulaması ister karmaşık bir mikro hizmet mimarisi geliştiriyor olun, doğru bağlantı noktası yönetimi başarının kritik unsurudur.

Kapsayıcılar modern uygulama dağıtım stratejilerine hükmetmeye devam ettikçe, Docker ağ yapılandırmasını ve bağlantı noktalarını güvenle yönetebilme yeteneği her geliştiricinin araç setinde vazgeçilmez bir beceri olarak kalacaktır.

Öğrenmeye devam etmek için şu kaynaklara göz atmayı unutmayın:

• Docker Kullanarak LLM Uygulamaları Nasıl Dağıtılır: Adım Adım Kılavuz
• 2025 için Eksiksiz Docker Sertifikasyonu (DCA) Kılavuzu
• 2025 İçin En İyi 26 Docker Mülakat Sorusu ve Cevabı 
• 10 Docker Proje Fikri: Başlangıçtan İleri Seviyeye