Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# SSH langsung
<a name="direct-ssh-access"></a>

**Pemberitahuan keamanan**  
Direct SSH membuka port TCP inbound pada pod cluster Anda. Kami merekomendasikan [Akses jarak jauh menggunakan SSH melalui SSM](vscode-access.md) karena tidak memerlukan port masuk terbuka. Hanya aktifkan SSH Langsung jika akses jarak jauh melalui SSM tidak dapat memenuhi kebutuhan Anda (misalnya, tidak ada akses internet, atau perkakas SSH standar yang diperlukan).

Sebelum mengaktifkan, tinjau hal-hal berikut:

Cluster-wide dampak  
`directSSH.enabled: true`membuka port yang dikonfigurasi pada semua pod ruang kerja di seluruh cluster, bukan hanya ruang kerja atau pengguna yang dipilih.

Ruang lingkup kelompok keamanan  
Batasi aturan masuk ke blok Classless Inter-Domain Routing (CIDR) sumber yang paling sempit. Jangan pernah gunakan`0.0.0.0/0`. Audit secara teratur menggunakan aturan AWS terkelola Config [restricted-ssh](https://docs.aws.amazon.com/config/latest/developerguide/restricted-ssh.html).

Siklus hidup kunci SSH  
Anda mengelola siklus hidup kunci SSH. Kunci SSH adalah kredensil berumur panjang. Tanpa kebijakan rotasi, kunci yang dikompromikan memberikan akses terus-menerus. Buat kebijakan rotasi kunci SSH, dan putar kunci secara berkala, sebelum diluncurkan ke tim Anda.

Isolasi jaringan VPC  
Anda mengelola isolasi jaringan VPC. Saat Anda mengaktifkan Direct SSH, sshd dimulai di pod, dan grup keamanan VPC Anda serta kontrol perutean yang dapat mencapainya. Pastikan hanya sumber jaringan tepercaya (subnet VPN, Direct Connect CIDR, atau jangkauan jaringan perusahaan) yang dapat mencapai port yang dikonfigurasi. Direct SSH mengekspos port SSH pada alamat IP pribadi pod di dalam VPC Anda. Klien dapat mencapainya hanya jika memiliki konektivitas jaringan ke VPC itu, melalui VPC yang sama, VPC peering, VPN, atau Direct Connect.

## Prasyarat
<a name="direct-ssh-prereq"></a>

Direct SSH memerlukan ExternalDNS, Amazon Route 53 Private Hosted Zone, konektivitas VPC dari mesin klien, dan (opsional) Load Balancer Controller. AWS Untuk daftar lengkap prasyarat, lihat. [Prasyarat untuk SSH Langsung](permission-setup.md#permission-direct-ssh)

Jika akses browser web sudah diaktifkan di cluster Anda, semua prasyarat sudah ada. Sebelum Anda melanjutkan, verifikasi ExternalDNS Anda dikonfigurasi dengan. `--policy=sync` Lihat perinciannya di [Konfigurasi ExternalDNS](#direct-ssh-appendix-externaldns).

Jika akses browser web belum dikonfigurasi, lihat[(Opsional) Menyiapkan prasyarat](#direct-ssh-appendix). Untuk informasi selengkapnya tentang mengaktifkan akses browser web, lihat[Instalasi EKS Addon - Jupyter K8s dengan WebUI](operator-install.md#webui-install).

## Konfigurasikan Direct SSH untuk klaster Anda
<a name="direct-ssh-admin"></a>

**Cluster-wide ruang lingkup**  
`directSSH.enabled: true`memulai sshd pada port yang dikonfigurasi di semua pod ruang kerja di seluruh cluster. SSH menyediakan akses yang sama dengan JupyterLab terminal: user yang sama (`sagemaker-user`), sistem file yang sama.

### Langkah 1: Tambahkan aturan grup keamanan untuk SSH
<a name="direct-ssh-admin-sg"></a>

Akses browser web menggunakan HTTPS (443) melalui Application Load Balancer (ALB). Karena Direct SSH terhubung langsung ke IP pod pada port yang dikonfigurasi, Anda perlu menambahkan aturan masuk grup keamanan.

**Konfigurasi VPC adalah tanggung jawab Anda**  
Anda harus mengonfigurasi VPC dengan benar, termasuk grup keamanan, perutean, dan kontrol akses jaringan. SSH langsung memulai sshd pada pod. VPC Anda menentukan siapa yang bisa mencapainya. Batasi akses hanya ke CIDR yang dapat SSH ke ruang kerja (misalnya, jangkauan jaringan perusahaan Anda, subnet terowongan VPN, atau Direct Connect CIDR). Jangan gunakan `0.0.0.0/0`.

**Verifikasi grup keamanan yang benar sebelum memodifikasi**  
HyperPod grup instance dapat mengganti konfigurasi VPC di tingkat grup, termasuk grup `OverrideVpcConfig` keamanan. Grup keamanan yang benar untuk dimodifikasi bergantung pada apakah grup instans ruang kerja Anda memiliki penggantian. Menambahkan aturan ke grup keamanan yang salah menghasilkan `Connection timed out` kesalahan diam.

Periksa apakah grup instans ruang kerja Anda memiliki penggantian SG:

```
aws sagemaker describe-cluster \
  --cluster-name <HYPERPOD_CLUSTER_NAME> \
  --region <AWS_REGION> \
  --query 'InstanceGroups[*].{Name:InstanceGroupName, OverrideSGs:OverrideVpcConfig.SecurityGroupIds}'
```

#### Opsi A: Grup instance memiliki penggantian grup keamanan
<a name="direct-ssh-admin-sg-override"></a>

Jika `OverrideSGs` non-null, tambahkan aturan ke Grup Keamanan tersebut:

```
SG_ID=<SG_ID_FROM_OVERRIDE_VPC_CONFIG>
aws ec2 authorize-security-group-ingress \
  --group-id $SG_ID \
  --protocol tcp \
  --port <SSH_PORT> \
  --cidr <SOURCE_CIDR> \
  --region <AWS_REGION>
```

#### Opsi B: Grup instance tidak memiliki penggantian grup keamanan
<a name="direct-ssh-admin-sg-cluster"></a>

Jika `OverrideSGs` nol, gunakan Grup Keamanan tingkat cluster dari konfigurasi VPC cluster SageMaker HyperPod :

```
SG_ID=$(aws sagemaker describe-cluster --cluster-name <HYPERPOD_CLUSTER_NAME> --region <AWS_REGION> \
  --query 'VpcConfig.SecurityGroupIds[0]' --output text)
aws ec2 authorize-security-group-ingress \
  --group-id $SG_ID \
  --protocol tcp \
  --port <SSH_PORT> \
  --cidr <SOURCE_CIDR> \
  --region <AWS_REGION>
```

Tabel berikut menunjukkan di mana untuk menemukan setiap nilai placeholder.


| Placeholder | Dimana mendapatkannya | 
| --- | --- | 
| <HYPERPOD\_CLUSTER\_NAME> | Di dalam SageMaker Konsol Manajemen AWS, pilih HyperPod Cluster. Atau lariaws sagemaker list-clusters. | 
| <SSH\_PORT> | Port yang Anda konfigurasikan directSSH.port (defaultnya adalah 22). Itu harus sesuai dengan aturan masuk grup keamanan. | 
| <AWS\_REGION> |  AWS Wilayah tempat cluster Anda HyperPod dan EKS dikerahkan. | 
| <SOURCE\_CIDR> | CIDR jaringan tepercaya Anda: VPN tunnel subnet, Direct Connect CIDR, atau jangkauan jaringan perusahaan (misalnya, 10.192.16. 0/24). Tidak boleh 0.0.0. 0/0. | 

### Langkah 2: Aktifkan SSH Langsung
<a name="direct-ssh-admin-enable"></a>

Tambahkan `directSSH` ke konfigurasi addon Anda di samping`clusterWebUI`:

```
jupyter-k8s-aws-hyperpod:
  clusterWebUI:
    enabled: true
    domain: "<DOMAIN_NAME>"
    awsCertificateArn: "<ACM_CERTIFICATE_ARN>"
    traefik:
      shouldInstall: true
  directSSH:
    enabled: true
    port: <SSH_PORT>          # default: 22
    domain: "<ROUTE53_HOSTED_ZONE_DOMAIN>"
```

Tabel berikut menunjukkan di mana untuk menemukan setiap nilai placeholder.


| Placeholder | Dimana mendapatkannya | 
| --- | --- | 
| <DOMAIN\_NAME> | Domain yang Anda konfigurasikan saat mengaktifkan akses browser web (misalnya, spaces.example.com). Untuk informasi selengkapnya, lihat [Instalasi EKS Addon - Jupyter K8s dengan WebUI](operator-install.md#webui-install). | 
| <ACM\_CERTIFICATE\_ARN> | AWS Certificate Manager (ACM) Konsol Manajemen AWS, pilih Certificates, lalu pilih sertifikat wildcard ARN | 
| <ROUTE53\_HOSTED\_ZONE\_DOMAIN> | Route 53 Konsol Manajemen AWS, pilih Zona yang Dihosting, lalu pilih nama Private Hosted Zone yang digunakan untuk ExternalDNS (misalnya, workspaces.internal) | 
| <SSH\_PORT> | Port sshd mendengarkan di dalam pod ruang kerja. Default 22. Gunakan port yang tidak memiliki hak istimewa (misalnya, 2222) jika grup keamanan atau kebijakan perusahaan Anda membatasi port 22. Aturan masuk SG harus cocok dengan nilai ini. | 

**DirectSSH dan RemoteAccess saling eksklusif**  
`directSSH`dan `remoteAccess` saling eksklusif. Mengaktifkan kedua penyebab `helm upgrade` gagal dengan: “DirectSSH dan RemoteAccess saling eksklusif. Aktifkan hanya satu.” Nonaktifkan `remoteAccess` sebelum mengaktifkan`directSSH`.

Perbarui addon:

```
aws eks update-addon \
  --cluster-name <CLUSTER_NAME> \
  --addon-name amazon-sagemaker-spaces \
  --configuration-values file://addon-config.yaml \
  --resolve-conflicts OVERWRITE \
  --region <AWS_REGION>
```

Untuk menonaktifkan Direct SSH, lihat[Mencabut akses SSH Langsung](#direct-ssh-revoke).

### Langkah 3: Verifikasi Direct SSH aktif
<a name="direct-ssh-admin-verify"></a>

```
# Check addon status
aws eks describe-addon \
  --cluster-name <CLUSTER_NAME> \
  --addon-name amazon-sagemaker-spaces \
  --region <AWS_REGION>

# Check headless services created for workspaces
kubectl get svc -l app.kubernetes.io/component=direct-ssh

# Verify DNS record resolves (from within VPC)
dig <workspace-name>.<namespace>.<ROUTE53_HOSTED_ZONE_DOMAIN>
```

## Connect ke ruang kerja Anda menggunakan Direct SSH
<a name="direct-ssh-enduser"></a>

Gunakan prosedur berikut untuk terhubung ke ruang kerja Anda menggunakan Direct SSH, mengelola kunci SSH Anda, dan memecahkan masalah koneksi.

### Cara kerja otentikasi SSH
<a name="direct-ssh-enduser-auth"></a>

Direct SSH menggunakan otentikasi kunci publik standar. Setiap pengguna menghasilkan key pair SSH mereka sendiri dan menambahkan kunci publik ke ruang kerja mereka. Kunci pribadi tidak pernah meninggalkan mesin pengguna.

Berikut ini adalah fakta-fakta kunci tentang akses SSH:
+ SSH memberikan akses yang sama dengan JupyterLab terminal: user yang sama (`sagemaker-user`), sistem file yang sama, alat yang sama.
+ Kunci adalah per-ruang kerja. Kunci dalam satu ruang kerja tidak memberikan akses ke ruang kerja lain.
+ Skrip startup SageMaker AI Spaces secara otomatis membuat `.ssh/` direktori dengan izin yang benar.
+ Kunci tetap ada di seluruh ruang kerja dimulai ulang (disimpan di PVC) dan dihapus saat ruang kerja dihapus.

**Batasan saat ini**  
Nama pengguna SSH selalu `sagemaker-user` terlepas dari siapa yang terhubung. Anda tidak dapat menggunakan nama pengguna pribadi. Semua sesi berjalan sebagai pengguna ruang kerja yang sama. Per-user identitas dalam prompt shell dan log audit tidak tersedia dalam rilis saat ini.

### Langkah 1: Buat kunci SSH di mesin klien Anda
<a name="direct-ssh-enduser-keygen"></a>

Jalankan perintah ini sekali untuk membuat key pair Anda:

```
ssh-keygen -t ed25519 -f ~/.ssh/my-workspace-key
```

Ini menciptakan:
+ `~/.ssh/my-workspace-key`— kunci pribadi (merahasiakan, tidak pernah berbagi)
+ `~/.ssh/my-workspace-key.pub`— kunci publik (tambahkan ke ruang kerja Anda)

### Langkah 2: Tambahkan kunci publik Anda ke ruang kerja Anda
<a name="direct-ssh-enduser-addkey"></a>

Gunakan **salah satu** metode berikut untuk menambahkan kunci publik Anda. Anda tidak perlu melakukan keduanya.

#### Tambahkan kunci Anda melalui akses browser web
<a name="direct-ssh-enduser-addkey-webui"></a>

1. Buka ruang kerja Anda di browser (lihat[Akses browser web](browser-access.md)).

1. Buka terminal. Di JupyterLab, pilih **File**, **Baru**, **Terminal**. Di Editor Kode, pilih **Terminal**, **Terminal Baru**.

1. Salin kunci publik Anda dari mesin lokal Anda: `cat ~/.ssh/my-workspace-key.pub`

1. Tempel ke terminal ruang kerja:

   ```
   echo "ssh-ed25519 AAAA...your-key... user@machine" >> ~/.ssh/authorized_keys
   ```

#### Tambahkan kunci Anda melalui kubectl
<a name="direct-ssh-enduser-addkey-kubectl"></a>

```
POD=$(kubectl get pods -n <namespace> -l workspace.jupyter.org/workspace-name=<space-name> \
  -o jsonpath='{.items[0].metadata.name}')
cat ~/.ssh/my-workspace-key.pub | kubectl exec -n <namespace> -i $POD -c workspace -- \
  bash -c "cat >> /home/sagemaker-user/.ssh/authorized_keys"
```

### Langkah 3: Connect ke ruang kerja Anda menggunakan SSH
<a name="direct-ssh-enduser-connect"></a>

```
ssh -p <SSH_PORT> -i ~/.ssh/my-workspace-key sagemaker-user@<space-name>.<namespace>.<domain>
```

**Pelabuhan SSH**  
Gunakan port SSH yang dikonfigurasi administrator Anda untuk Direct SSH. Jika administrator Anda menyimpan port default (22), Anda dapat menghilangkan `-p` opsi. Jika mereka mengkonfigurasi port non-default (misalnya, 2222), Anda harus menyertakan `-p <SSH_PORT>` atau koneksi gagal. `Connection refused` Hubungi administrator Anda jika Anda tidak yakin port mana yang akan digunakan.

Contoh:

```
ssh -p 2222 -i ~/.ssh/my-workspace-key sagemaker-user@my-space.default.spaces.example.com
```

### Langkah 4: Konfigurasikan SSH untuk akses mudah
<a name="direct-ssh-enduser-config"></a>

Langkah opsional ini menyederhanakan koneksi future. Tambahkan berikut ini ke `~/.ssh/config`:

```
Host my-space
    HostName <space-name>.<namespace>.<domain>
    Port <SSH_PORT>
    User sagemaker-user
    IdentityFile ~/.ssh/my-workspace-key
    ServerAliveInterval 15
    ServerAliveCountMax 3
```

Setel `Port` ke port yang dikonfigurasi administrator Anda. Anda dapat menghilangkan baris ini jika Direct SSH menggunakan port default (22). Kemudian terhubung dengan: `ssh my-space`

### Langkah 5: Hubungkan IDE jarak jauh
<a name="direct-ssh-enduser-ide"></a>

Setelah Direct SSH bekerja dari terminal Anda (Langkah 3), setiap IDE yang Remote-SSH mampu terhubung menggunakan `~/.ssh/config` entri yang sama. Anda tidak memerlukan AWS konfigurasi tambahan untuk koneksi ini.

#### Instal Remote-SSH ekstensi
<a name="direct-ssh-enduser-ide-install"></a>


| IDE | Ekstensi | 
| --- | --- | 
| VS Code | Ekstensi, cari “Remote - SSH”, pilih Instal (oleh Microsoft) | 
| Kiro | Ekstensi, cari “Remote - SSH”, pilih Instal | 
| Kursor | Ekstensi, cari “Remote - SSH”, pilih Instal | 

#### Connect dari IDE
<a name="direct-ssh-enduser-ide-connect"></a>

1. Buka **Command Palette**, lalu pilih "Remote-SSH: Connect to Host...”

1. Pilih ruang kerja Anda dari daftar (gunakan `~/.ssh/config` dari Langkah 4).

1. IDE menginstal komponen servernya di ruang kerja (satu kali, sekitar 30 detik).

1. Jendela jarak jauh terbuka dengan fitur editor lengkap, termasuk IntelliSense, terminal, dan file explorer.

**Buka file ruang kerja Anda di VS Code**  
Di VS Code, setelah menghubungkan, pilih **File**, **Buka Folder**, `/home/sagemaker-user` untuk membuka file ruang kerja Anda secara langsung.

### Manajemen kunci dan pencabutan
<a name="direct-ssh-enduser-keys"></a>

Anda mengelola kunci SSH Anda. Kunci SSH adalah kredensil berumur panjang tanpa kedaluwarsa otomatis. Kunci dalam `authorized_keys` memberikan akses ke ruang kerja Anda sampai Anda menghapusnya secara eksplisit.

#### Untuk memutar kunci Anda
<a name="direct-ssh-enduser-keys-rotate"></a>

Kami merekomendasikan memutar kunci Anda secara berkala.

1. Buat key pair baru di mesin klien Anda: `ssh-keygen -t ed25519 -f ~/.ssh/my-workspace-key-new`

1. Tambahkan kunci publik baru ke ruang kerja Anda (Langkah 2). Kunci lama dan baru bekerja secara bersamaan.

1. Verifikasi kunci baru berfungsi: `ssh -p <SSH_PORT> -i ~/.ssh/my-workspace-key-new sagemaker-user@<hostname>`

1. Hapus kunci lama dari `authorized_keys` terminal ruang kerja Anda:

   ```
   # List current keys with line numbers
   cat -n ~/.ssh/authorized_keys
   # Remove a specific line (for example, line 1)
   sed -i '1d' ~/.ssh/authorized_keys
   ```

#### Jika kunci pribadi Anda dikompromikan
<a name="direct-ssh-enduser-keys-compromised"></a>

Bertindak segera. Kunci yang dikompromikan memberikan akses ruang kerja penuh hingga Anda menghapusnya. `authorized_keys`

1. Buka ruang kerja Anda melalui akses browser web (JupyterLab atau Editor Kode). Untuk petunjuk, lihat [Akses browser web](browser-access.md).

1. Hapus kunci yang disusupi dari`authorized_keys`:

   ```
   # View all authorized keys
   cat ~/.ssh/authorized_keys
   # Option A: Edit directly
   nano ~/.ssh/authorized_keys
   # Option B: Remove all keys and re-add only trusted ones
   > ~/.ssh/authorized_keys
   echo "ssh-ed25519 AAAA...new-trusted-key..." >> ~/.ssh/authorized_keys
   ```

1. Verifikasi kunci yang disusupi tidak lagi berfungsi dengan mencoba terhubung dengannya. Anda harus menerima`Permission denied (publickey)`.

1. Jika Anda tidak dapat mengakses ruang kerja melalui akses browser web, hubungi administrator klaster Anda untuk mengeksekusi ke pod dan mengosongkan `authorized_keys` secara langsung.

#### Praktik terbaik
<a name="direct-ssh-enduser-keys-practices"></a>


| Berlatih | Mengapa | 
| --- | --- | 
| Gunakan tombol ed25519 | Lebih pendek, lebih cepat, lebih aman dari RSA | 
| Gunakan frasa sandi pada kunci pribadi Anda | Melindungi dari pencurian kunci. Bahkan jika dicuri, kunci tidak dapat digunakan tanpa frasa sandi. | 
| Satu kunci per perangkat | Lebih mudah untuk mencabut akses satu perangkat tanpa mempengaruhi orang lain | 
| Jangan pernah berbagi kunci pribadi | Setiap pengguna dan perangkat harus memiliki key pair sendiri | 
| Tinjau authorized\_keys secara berkala | Hapus kunci untuk perangkat yang tidak lagi Anda gunakan | 

## Mencabut akses SSH Langsung
<a name="direct-ssh-revoke"></a>

Untuk menghindari meninggalkan aturan grup keamanan terbuka setelah Anda menonaktifkan Direct SSH, selesaikan ketiga langkah secara berurutan. Jangan lewati Langkah 2.

**Beri tahu pengguna Anda sebelum mencabut akses**  
Beri tahu pengguna Anda sebelum Anda mencabut akses. ExternalDNS menghapus catatan DNS dalam waktu sekitar 30 detik dari Langkah 3, yang memblokir koneksi baru.

### Langkah 1: Nonaktifkan di bagan Helm
<a name="direct-ssh-revoke-helm"></a>

Hapus `directSSH` bagian dari file konfigurasi addon Anda sepenuhnya. Helm default `false` ketika kunci `directSSH.enabled` tidak ada:

```
jupyter-k8s-aws-hyperpod:
  clusterWebUI:
    enabled: true
    domain: "<DOMAIN_NAME>"
    ...
  # directSSH section removed
```

Atau, atur secara eksplisit: `enabled: false`

```
directSSH:
  enabled: false
```

### Langkah 2: Hapus aturan masuk grup keamanan
<a name="direct-ssh-revoke-sg"></a>

```
# Find the rule ID
aws ec2 describe-security-group-rules \
  --filters Name=group-id,Values=<SG_ID> \
  --query 'SecurityGroupRules[?IpProtocol==`tcp` && FromPort==`<SSH_PORT>`].[SecurityGroupRuleId,CidrIpv4]' \
  --output table \
  --region <AWS_REGION>

# Remove the rule
aws ec2 revoke-security-group-ingress \
  --group-id <SG_ID> \
  --security-group-rule-ids <RULE_ID> \
  --region <AWS_REGION>
```

### Langkah 3: Terapkan ke cluster
<a name="direct-ssh-revoke-apply"></a>

```
aws eks update-addon \
  --cluster-name <CLUSTER_NAME> \
  --addon-name amazon-sagemaker-spaces \
  --configuration-values file://addon-config.yaml \
  --resolve-conflicts OVERWRITE \
  --region <AWS_REGION>
```

Menjalankan perintah ini menghapus Layanan tanpa kepala untuk semua ruang kerja. ExternalDNS kemudian menghapus catatan Route 53 A dalam waktu sekitar 30 detik. Setelah ExternalDNS menghapus catatan, koneksi SSH baru tidak dapat lagi menyelesaikan nama host ruang kerja.

### Apa yang terjadi setelah pencabutan
<a name="direct-ssh-revoke-after"></a>


| Komponen | Negara setelah pencabutan | 
| --- | --- | 
| Catatan DNS | ExternalDNS menghapusnya dalam waktu sekitar 30 detik. Koneksi baru tidak dapat menyelesaikan nama host ruang kerja. | 
| Aturan masuk SG | Ditutup setelah Langkah 2. Tidak ada jalur jaringan yang mencapai port. | 
| Koneksi SSH baru | Diblokir. Nama host tidak lagi diselesaikan, dan aturan SG menutup port. | 
| Data ruang kerja (PVC) | Tidak terpengaruh. PVC menyimpan file Anda, authorized\_keys, dan kunci host. | 

## Pemecahan masalah
<a name="direct-ssh-troubleshooting"></a>


| Gejala | Penyebab | Perbaiki | 
| --- | --- | --- | 
| NXDOMAIN | DNS tidak menyelesaikan | Verifikasi zona yang dihosting ada, terkait VPC, ExternalDNS berjalan | 
| Connection timed out | Pemblokiran SG: aturan ditambahkan ke SG yang salah atau hilang seluruhnya | Periksa grup OverrideVpcConfig instans (Langkah Admin 1). Verifikasi aturan masuk TCP mencakup CIDR sumber Anda. | 
| Connection refused | sshd tidak berjalan | Periksa ruang dalam status Running dan directSSH diaktifkan | 
| Permission denied (publickey) | Kunci tidak masuk authorized\_keys | Tambahkan kunci publik melalui akses browser web atau kubectl (Pengguna Akhir Langkah 2) | 
| Host key changedperingatan | Spasi telah dibuat ulang (pod baru, kunci host baru) | Di mesin klien Anda: ssh-keygen -R <hostname> lalu sambungkan kembali | 
| Stale DNS records after space deletion | ExternalDNS berjalan dengan --policy=upsert-only | Perbarui penerapan ExternalDNS ke dan tambahkan. --policy=sync --txt-owner-id=<cluster-name> Bersihkan catatan basi yang ada secara manual: aws route53 list-resource-record-sets --hosted-zone-id <ZONE\_ID> | 
| IDE: “Tidak dapat membuat koneksi” | sshd belum siap | Tunggu 60-90 detik setelah pembuatan ruang kerja, lalu coba lagi | 
| IDE: Bertahan di “Menginstal VS Code Server” | Workspace tidak memiliki akses internet | Ruang kerja Anda mengunduh biner server VS Code dari host eksternal pada koneksi pertama. Hubungi administrator Anda jika ruang kerja mengalami celah udara. | 
| IDE: Permission denied | IdentityFile ketidakcocokan jalur | Verifikasi terminal SSH berfungsi terlebih dahulu, lalu check in IdentityFile \~/.ssh/config | 
| IDE: Koneksi turun setelah idle | Tidak ada keepalive yang dikonfigurasi | Tambahkan ServerAliveInterval 15 dan ServerAliveCountMax 3 ke \~/.ssh/config | 

## (Opsional) Menyiapkan prasyarat
<a name="direct-ssh-appendix"></a>

Gunakan bagian ini hanya jika akses browser web belum diaktifkan, atau untuk memverifikasi atau memperbarui konfigurasi ExternalDNS Anda.

### Instalasi dari awal
<a name="direct-ssh-appendix-scratch"></a>

Jika akses browser web belum dikonfigurasi, Anda memerlukan yang berikut ini sebelum mengaktifkan Direct SSH:

1. **Route 53 zona host** — domain atau subdomain yang Anda miliki, terdaftar di Route 53

1. **DNS eksternal** — digunakan melalui add-on EKS, dengan peran IAM memiliki izin Route 53

1. **AWS Load Balancer Controller** - diperlukan jika Anda menggunakan akses browser web (ALB ingress). Untuk catatan HyperPod-specific instalasi, lihat[AWS Load Balancer Controller: persyaratan HyperPod vPCID](#direct-ssh-appendix-lbc).

1. **Konektivitas VPC** — VPN atau Direct Connect dari mesin klien ke VPC

Untuk dependensi tambahan dan langkah-langkah konfigurasi akses browser web, lihat. [Instal SageMaker AI Spaces Add-on](operator-install.md)

### AWS Load Balancer Controller: persyaratan HyperPod vPCID
<a name="direct-ssh-appendix-lbc"></a>

Dokumentasi instalasi AWS Load Balancer Controller standar tidak menyebutkan parameternya. `vpcId` Pada HyperPod cluster, menghilangkan `vpcId` menyebabkan instalasi gagal. Anda harus memberikannya secara eksplisit.

Dapatkan ID VPC Anda:

```
aws sagemaker describe-cluster \
  --cluster-name <HYPERPOD_CLUSTER_NAME> \
  --region <AWS_REGION> \
  --query 'VpcConfig.VpcId' \
  --output text
```

Instal dengan HyperPod parameter yang diperlukan:

```
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
  -n kube-system \
  --set clusterName=<EKS_CLUSTER_NAME> \
  --set serviceAccount.create=false \
  --set serviceAccount.name=aws-load-balancer-controller \
  --set enableServiceMutatorWebhook=false \
  --set vpcId=<VPC_ID>
```


| Parameter | Mengapa diperlukan pada HyperPod | 
| --- | --- | 
| vpcId | HyperPod VPC tidak dapat ditemukan secara otomatis oleh pengontrol. Instalasi gagal tanpanya. | 
| enableServiceMutatorWebhook=false | Webhook yang bermutasi bertentangan dengan konfigurasi HyperPod layanan | 
| serviceAccount.create=false | Akun layanan harus dibuat sebelumnya dengan anotasi IRSA atau Pod Identity yang benar sebelum menginstal | 

Buat akun layanan (aws-load-balancer-controller) dengan anotasi peran IAM yang sesuai sebelum menjalankan perintah ini. Untuk informasi selengkapnya tentang kebijakan IAM dan langkah pembuatan akun layanan, lihat Pengaturan [IRSA Pengontrol Load Balancer Amazon EKS di Panduan](https://docs.aws.amazon.com/eks/latest/userguide/lbc-helm.html) Pengguna Amazon EKS.

### Konfigurasi ExternalDNS
<a name="direct-ssh-appendix-externaldns"></a>

ExternalDNS menyinkronkan Layanan Kubernetes dengan penyedia DNS. Konfigurasikan ExternalDNS dengan pengaturan berikut saat Anda menggunakannya dengan Amazon Route 53 di lingkungan produksi.

**ExternalDNS memerlukan kebijakan sinkronisasi**  
Anda harus mengkonfigurasi ExternalDNS dengan. `--policy=sync`

Secara default, ExternalDNS menggunakan. `--policy=upsert-only` Ini membuat dan memperbarui catatan DNS tetapi tidak pernah menghapusnya. Saat Anda menghapus ruang kerja, catatan A dan TXT di Amazon Route 53 tetap sebagai entri basi.

Gunakan `--policy=upsert-only` hanya untuk pengujian, dan ubah menjadi `--policy=sync` untuk produksi. Anda juga harus menyetel `--txt-owner-id` bendera, yang memberi tahu ExternalDNS catatan mana yang dimilikinya dan catatan mana yang akan dihapus saat pembersihan.

Konfigurasikan penerapan ExternalDNS Anda dengan argumen berikut:

```
--provider=aws
--source=service                          # watches Services (required for headless Services)
--domain-filter=<ROUTE53_HOSTED_ZONE>     # restricts ExternalDNS to your hosted zone only
--policy=sync                             # enables deletion of stale records on space deletion
--txt-owner-id=<CLUSTER_NAME>             # identifies which records this ExternalDNS instance owns
```

Dalam argumen sebelumnya, ganti nilai-nilai berikut:
+ `<ROUTE53_HOSTED_ZONE>`— Domain zona host pribadi Amazon Route 53 Anda (misalnya,`workspaces.internal`)
+ `<CLUSTER_NAME>`— nama cluster EKS Anda (misalnya,`my-hyperpod-cluster`)

Untuk memverifikasi kebijakan ExternalDNS Anda saat ini, jalankan perintah berikut:

```
kubectl get deployment -n kube-system external-dns \
  -o jsonpath='{.spec.template.spec.containers[0].args}' | tr ',' '\n' | grep -E 'policy|owner|source|domain'
```