

 **Bantu meningkatkan halaman ini ** 

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

Untuk berkontribusi pada panduan pengguna ini, pilih GitHub ** tautan ** Edit halaman ini di yang terletak di panel kanan setiap halaman.

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

# Konfigurasikan izin CD Argo
<a name="argocd-permissions"></a>

Kemampuan terkelola CD Argo terintegrasi dengan AWS Identity Center untuk otentikasi dan menggunakan peran RBAC bawaan untuk otorisasi. Topik ini menjelaskan cara mengonfigurasi izin untuk pengguna dan tim.

## Cara kerja izin dengan Argo CD
<a name="_how_permissions_work_with_argo_cd"></a>

Kemampuan CD Argo menggunakan AWS Identity Center untuk otentikasi dan menyediakan tiga peran RBAC bawaan untuk otorisasi.

Saat pengguna mengakses CD Argo:

1. Mereka mengotentikasi menggunakan AWS Identity Center (yang dapat bergabung dengan penyedia identitas perusahaan Anda)

1.  AWS Identity Center menyediakan informasi pengguna dan grup ke Argo CD

1. Argo CD memetakan pengguna dan grup ke peran RBAC berdasarkan konfigurasi Anda

1. Pengguna hanya melihat aplikasi dan sumber daya yang mereka miliki izin untuk mengakses

## Built-in Peran RBAC
<a name="_built_in_rbac_roles"></a>

Kemampuan CD Argo menyediakan tiga peran bawaan yang Anda petakan ke pengguna dan grup AWS Identity Center. Ini adalah peran ** cakupan global ** yang mengontrol akses ke sumber daya Argo CD seperti proyek, cluster, dan repositori.

**penting**  
Peran global mengontrol akses ke Argo CD itu sendiri, bukan ke sumber daya dengan cakupan proyek seperti Aplikasi. Pengguna EDITOR dan VIEWER tidak dapat melihat atau mengelola Aplikasi secara default—mereka memerlukan peran proyek untuk mengakses sumber daya dengan cakupan proyek. Lihat [Peran proyek dan akses cakupan proyek](#project-roles) untuk detail tentang pemberian akses ke Aplikasi dan sumber daya cakupan proyek lainnya.

 **ADMIN ** 

Akses penuh ke semua sumber daya dan pengaturan CD Argo:
+ Membuat, memperbarui, dan menghapus Aplikasi dan ApplicationSets dalam proyek apa pun
+ Kelola konfigurasi CD Argo
+ Mendaftarkan dan mengelola cluster target penerapan
+ Konfigurasikan akses repositori
+ Membuat dan mengelola proyek
+ Lihat semua status dan riwayat aplikasi
+ Daftar dan akses semua cluster dan repositori

 **EDITOR ** 

Dapat memperbarui proyek dan mengkonfigurasi peran proyek, tetapi tidak dapat mengubah pengaturan CD Argo global:
+ Memperbarui proyek yang ada (tidak dapat membuat atau menghapus proyek)
+ Konfigurasikan peran dan izin proyek
+ Lihat kunci dan sertifikat GPG
+ Tidak dapat mengubah konfigurasi CD Argo global
+ Tidak dapat mengelola cluster atau repositori secara langsung
+ Tidak dapat melihat atau mengelola Aplikasi tanpa peran proyek

 **PENAMPIL ** 

Read-only akses ke sumber daya CD Argo:
+ Lihat konfigurasi proyek
+ Daftar semua proyek (termasuk proyek yang tidak ditugaskan pengguna)
+ Lihat kunci dan sertifikat GPG
+ Tidak dapat membuat daftar cluster atau repositori
+ Tidak dapat membuat perubahan apa pun
+ Tidak dapat melihat atau mengelola Aplikasi tanpa peran proyek

**catatan**  
Untuk memberi pengguna EDITOR atau VIEWER akses ke Aplikasi, ADMIN atau EDITOR harus membuat peran proyek yang memetakan grup Pusat Identitas ke izin tertentu dalam proyek.

## Peran proyek dan akses cakupan proyek
<a name="project-roles"></a>

Peran global (ADMIN, EDITOR, VIEWER) mengontrol akses ke Argo CD itu sendiri. Peran proyek mengontrol akses ke sumber daya dan kemampuan dalam proyek tertentu, termasuk:
+  **Sumber daya**: Aplikasi ApplicationSets, kredenSIAL repositori, kredenSIAL cluster
+  **Kemampuan**: Akses log, akses exec ke pod aplikasi

 **Memahami model ** izin dua tingkat:
+  **Lingkup global**: Built-in peran menentukan apa yang dapat dilakukan pengguna dengan proyek, cluster, repositori, dan pengaturan CD Argo
+  **Lingkup proyek**: Peran proyek menentukan apa yang dapat dilakukan pengguna dengan sumber daya dan kemampuan dalam proyek tertentu

Ini berarti:
+ Pengguna ADMIN dapat mengakses semua sumber daya proyek dan kemampuan tanpa konfigurasi tambahan
+ Pengguna EDITOR dan VIEWER harus diberikan peran proyek untuk mengakses sumber daya dan kemampuan proyek
+ Pengguna EDITOR dapat membuat peran proyek untuk memberi diri mereka sendiri dan orang lain akses dalam proyek yang dapat mereka perbarui

 **Contoh alur kerja**:

1. Admin memetakan grup Pusat Identitas ke peran EDITOR secara global

1. Admin membuat proyek untuk tim

1. EDITOR mengonfigurasi peran proyek dalam proyek tersebut untuk memberikan anggota tim akses ke sumber daya bercakupan proyek

1. Anggota tim (yang mungkin memiliki peran global VIEWER) sekarang dapat melihat dan mengelola Aplikasi dalam proyek tersebut berdasarkan izin peran proyek mereka

Untuk detail tentang mengonfigurasi peran proyek, lihat[Project-based kontrol akses](#_project_based_access_control).

## Konfigurasikan pemetaan peran
<a name="_configure_role_mappings"></a>

Pet AWS akan pengguna dan grup Identity Center ke peran CD Argo saat membuat atau memperbarui kemampuan.

 **Contoh pemetaan peran**:

```
{
  "rbacRoleMappings": {		 	 	 
    "ADMIN": ["AdminGroup", "alice@example.com"],
    "EDITOR": ["DeveloperGroup", "DevOpsTeam"],
    "VIEWER": ["ReadOnlyGroup", "bob@example.com"]
  }
}
```

**catatan**  
Nama peran peka huruf besar dan harus huruf besar (ADMIN, EDITOR, VIEWER).

**penting**  
Integrasi EKS Capabilities dengan AWS Identity Center mendukung hingga 1.000 identitas per kemampuan CD Argo. Identitas dapat berupa pengguna atau grup.

 **Perbarui pemetaan peran: **

```
aws eks update-capability \
  --region {{us-east-1}} \
  --cluster-name {{cluster}} \
  --capability-name {{capname}} \
  --role-arn {{"arn:aws:iam::111122223333:role/EKSCapabilityRole"}} \
  --configuration '{
    "argoCd": {
      "rbacRoleMappings": {
        "addOrUpdateRoleMappings": [
          {
            "role": "ADMIN",
            "identities": [
              { "id": "686103e0-f051-7068-b225-e6392b959d9e", "type": "SSO_USER" }
            ]
          }
        ]
      }
    }
  }'
```

## Penggunaan akun admin
<a name="_admin_account_usage"></a>

Akun admin dirancang untuk pengaturan awal dan tugas administratif seperti mendaftarkan cluster dan mengonfigurasi repositori.

 **Ketika akun admin sesuai**:
+ Pengaturan dan konfigurasi kemampuan awal
+ Pengembangan solo atau demonstrasi cepat
+ Tugas administratif (pendaftaran cluster, konfigurasi repositori, pembuatan proyek)

 **Praktik terbaik untuk akun admin**:
+ Jangan komit token akun ke kontrol versi
+ Putar token segera jika terbuka
+ Batasi penggunaan token akun untuk pengaturan dan tugas administratif
+ Tetapkan waktu kedaluwarsa pendek (maksimum 12 jam)
+ Hanya 5 token akun yang dapat dibuat pada waktu tertentu

 **Kapan menggunakan akses berbasis proyek sebagai gantinya: **
+ Lingkungan pengembangan bersama dengan banyak pengguna
+ Lingkungan apa pun yang menyerupai produksi
+ Ketika Anda membutuhkan jejak audit dari siapa yang melakukan tindakan
+ Saat Anda perlu menerapkan pembatasan sumber daya atau batas akses

Untuk lingkungan produksi dan skenario multi-pengguna, gunakan kontrol akses berbasis proyek dengan peran RBAC khusus yang dipetakan ke grup Pusat Identitas. AWS 

## Project-based kontrol akses
<a name="_project_based_access_control"></a>

Gunakan Argo CD Projects (AppProject) untuk menyediakan kontrol akses yang halus dan isolasi sumber daya untuk tim.

**penting**  
Sebelum menetapkan pengguna atau grup ke peran khusus proyek, Anda harus terlebih dahulu memetakannya ke peran CD Argo global (ADMIN, EDITOR, atau VIEWER) dalam konfigurasi kemampuan. Pengguna tidak dapat mengakses CD Argo tanpa pemetaan peran global, bahkan jika mereka ditugaskan ke peran proyek.  
Pertimbangkan untuk memetakan pengguna ke peran VIEWER secara global, lalu berikan izin tambahan melalui peran khusus proyek. Ini menyediakan akses dasar sambil memungkinkan kontrol berbutir halus di tingkat proyek.

Proyek menyediakan:
+  **Pembatasan sumber**: Batasi repositori Git mana yang dapat digunakan
+  **Pembatasan tujuan**: Batasi cluster dan ruang nama mana yang dapat ditargetkan
+  **Pembatasan sumber daya**: Batasi jenis sumber daya Kubernetes yang dapat digunakan
+  **Integrasi RBAC**: Memetakan proyek ke AWS grup Pusat Identitas atau peran CD Argo

 **Contoh proyek untuk isolasi tim**:

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a
  namespace: argocd
spec:
  description: Team A applications

  # Required: Specify which namespaces this project watches for Applications
  sourceNamespaces:
  - argocd

  # Source restrictions
  sourceRepos:
  - https://github.com/myorg/team-a-apps

  # Destination restrictions
  destinations:
  - namespace: team-a-*
    server: arn:aws:eks:us-west-2:111122223333:cluster/production

  # Resource restrictions
  clusterResourceWhitelist:
  - group: ''
    kind: Namespace
  namespaceResourceWhitelist:
  - group: 'apps'
    kind: Deployment
  - group: ''
    kind: Service
  - group: ''
    kind: ConfigMap
```

### Ruang nama sumber
<a name="_source_namespaces"></a>

Saat menggunakan kemampuan EKS Argo CD, `spec.sourceNamespaces` bidang tersebut diperlukan dalam AppProject definisi. Bidang ini menentukan namespace mana yang dapat berisi Aplikasi atau ApplicationSets yang mereferensikan proyek ini.

**penting**  
Kemampuan EKS Argo CD hanya mendukung satu namespace untuk Aplikasi dan ApplicationSets —namespace yang Anda tentukan saat membuat kemampuan (biasanya). `argocd` Ini berbeda dari open source Argo CD yang mendukung beberapa ruang nama.

 **AppProject konfigurasi ** 

Semua AppProjects harus menyertakan namespace kemampuan yang dikonfigurasi di: `sourceNamespaces`

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a-project
  namespace: argocd
spec:
  description: Applications for Team A

  # Required: Specify the capability's configured namespace (configuration.argoCd.namespace)
  sourceNamespaces:
    - argocd  # Must match your capability's namespace configuration

  # Source repositories this project can deploy from
  sourceRepos:
    - 'https://github.com/my-org/team-a-*'

  # Destination restrictions
  destinations:
    - namespace: 'team-a-*'
      server: arn:aws:eks:us-west-2:111122223333:cluster/my-cluster
```

**catatan**  
Jika Anda menghilangkan namespace kemampuan dari`sourceNamespaces`, Aplikasi atau ApplicationSets di namespace tersebut tidak dapat mereferensikan proyek ini, yang mengakibatkan kegagalan penerapan.

 **Menetapkan pengguna ke proyek**:

Peran proyek memberi pengguna EDITOR dan VIEWER akses ke sumber daya proyek (Aplikasi, ApplicationSets, repositori dan kredentif cluster) dan kemampuan (log, exec). Tanpa peran proyek, pengguna ini tidak dapat mengakses sumber daya ini meskipun mereka memiliki akses peran global.

Pengguna ADMIN memiliki akses ke semua Aplikasi tanpa memerlukan peran proyek.

 **Contoh: Memberikan akses Aplikasi kepada anggota tim ** 

```
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
  name: team-a
  namespace: argocd
spec:
  # ... project configuration ...

  sourceNamespaces:
  - argocd

  # Project roles grant Application-level access
  roles:
  - name: developer
    description: Team A developers - can manage Applications
    policies:
    - p, proj:team-a:developer, applications, *, team-a/*, allow
    - p, proj:team-a:developer, clusters, get, *, allow  # See cluster names in UI
    groups:
    - 686103e0-f051-7068-b225-e6392b959d9e  # Identity Center group ID

  - name: viewer
    description: Team A viewers - read-only Application access
    policies:
    - p, proj:team-a:viewer, applications, get, team-a/*, allow
    - p, proj:team-a:viewer, clusters, get, *, allow  # See cluster names in UI
    groups:
    - 786203e0-f051-7068-b225-e6392b959d9f  # Identity Center group ID
```

**catatan**  
Sertakan `clusters, get, *, allow` dalam peran proyek untuk memungkinkan pengguna melihat nama cluster di UI. Tanpa izin ini, cluster tujuan ditampilkan sebagai “tidak dikenal”.

 **Memahami kebijakan peran proyek**:

Format kebijakan adalah: `p, proj:<project>:<role>, <resource>, <action>, <object>, <allow/deny>` 

 **Kebijakan sumber daya**:
+  `applications, , team-a/, allow`- Akses penuh ke semua Aplikasi dalam tim - proyek
+  `applications, get, team-a/*, allow`- Read-only akses ke Aplikasi
+  `applications, sync, team-a/*, allow`- Dapat menyinkronkan Aplikasi tetapi tidak create/delete
+  `applications, delete, team-a/*, allow`- Dapat menghapus Aplikasi (gunakan dengan hati-hati)
+  `applicationsets, , team-a/, allow`- Akses penuh ke ApplicationSets
+  `repositories, *, *, allow`- Akses ke kredenSIAL repositori
+  `clusters, *, *, allow`- Akses ke kredentif cluster

 **Kebijakan kemampuan**:
+  `logs, , team-a/, allow`- Akses ke log aplikasi
+  `exec, , team-a/, allow`- Eksekusi akses ke pod aplikasi

**catatan**  
Pengguna EDITOR dapat membuat peran proyek untuk memberikan izin kepada diri mereka sendiri dan orang lain dalam proyek yang dapat mereka perbarui. Hal ini memungkinkan pimpinan tim untuk mengontrol akses ke sumber daya bercakupan proyek untuk tim mereka tanpa memerlukan intervensi ADMIN.

**catatan**  
Gunakan ID grup Pusat Identitas (bukan nama grup) di `groups` bidang. Anda juga dapat menggunakan ID pengguna Pusat Identitas untuk akses pengguna individual. Temukan ID ini di konsol AWS Identity Center atau menggunakan AWS CLI.

## Pola izin umum
<a name="_common_permission_patterns"></a>

 **Pola 1: Tim Admin dengan akses penuh ** 

```
{
  "rbacRoleMappings": {		 	 	 
    "ADMIN": ["PlatformTeam", "SRETeam"]
  }
}
```

Pengguna ADMIN dapat melihat dan mengelola semua sumber daya dengan cakupan proyek tanpa konfigurasi tambahan.

 **Pola 2: Pimpinan tim mengelola proyek, akses pengembang melalui peran proyek ** 

```
{
  "rbacRoleMappings": {		 	 	 
    "ADMIN": ["PlatformTeam"],
    "EDITOR": ["TeamLeads"],
    "VIEWER": ["AllDevelopers"]
  }
}
```

1. ADMIN membuat proyek untuk setiap tim

1. Pimpinan tim (EDITOR) mengonfigurasi peran proyek untuk memberikan akses pengembang mereka ke sumber daya proyek (Aplikasi, ApplicationSets, kredenSIAL) dan kemampuan (log, exec)

1. Pengembang (VIEWER) hanya dapat mengakses sumber daya dan kemampuan yang diizinkan oleh peran proyek mereka

 **Pola 3: Team-based akses dengan peran proyek ** 

1. ADMIN membuat proyek dan memetakan tim memimpin ke peran EDITOR secara global

1. Pemimpin tim (EDITOR) menugaskan anggota tim untuk peran proyek dalam proyek mereka

1. Anggota tim hanya membutuhkan peran global VIEWER — peran proyek menyediakan akses ke sumber daya dan kemampuan proyek

```
{
  "rbacRoleMappings": {		 	 	 
    "ADMIN": ["PlatformTeam"],
    "EDITOR": ["TeamLeads"],
    "VIEWER": ["AllDevelopers"]
  }
}
```

## Praktik terbaik
<a name="_best_practices"></a>

 **Gunakan grup alih-alih pengguna individu**: Petakan AWS grup Pusat Identitas ke peran CD Argo daripada pengguna individu untuk pengelolaan yang lebih mudah.

 **Mulailah dengan hak istimewa paling ** sedikit: Mulailah dengan akses VIEWER dan berikan EDITOR atau ADMIN sesuai kebutuhan.

 **Gunakan proyek untuk isolasi tim**: Buat terpisah AppProjects untuk tim atau lingkungan yang berbeda untuk menegakkan batasan.

 **Memanfaatkan federasi Pusat AWS Identitas**: Konfigurasikan Pusat Identitas untuk bergabung dengan penyedia identitas perusahaan Anda untuk manajemen pengguna terpusat.

 **Tinjauan akses regul ** er: Tinjau pemetaan peran dan penugasan proyek secara berkala untuk memastikan tingkat akses yang sesuai.

 **Batasi akses cluster**: Ingat bahwa Argo CD RBAC mengontrol akses ke sumber daya dan operasi Argo CD, tetapi tidak sesuai dengan Kubernetes RBAC. Pengguna dengan akses Argo CD dapat menyebarkan aplikasi ke cluster yang dapat diakses oleh Argo CD. Batasi cluster mana Argo CD dapat mengakses dan menggunakan pembatasan tujuan proyek untuk mengontrol di mana aplikasi dapat digunakan.

## AWS izin layanan
<a name="shared_aws_service_permissions"></a>

Untuk menggunakan AWS layanan secara langsung di sumber daya Aplikasi (tanpa membuat sumber daya Repositori), lampirkan izin IAM yang diperlukan ke Peran Kemampuan.

 **ECR untuk grafik Helm**:

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "ecr:GetAuthorizationToken",
        "ecr:BatchCheckLayerAvailability",
        "ecr:GetDownloadUrlForLayer",
        "ecr:BatchGetImage"
      ],
      "Resource": "*"
    }
  ]
}
```

 **CodeCommit repositori: **

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "codecommit:GitPull"
      ],
      "Resource": "arn:aws:codecommit:region:account-id:repository-name"
    }
  ]
}
```

 **CodeConnections (GitHub, GitLab, Bitbucket): **

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "codeconnections:UseConnection"
      ],
      "Resource": "arn:aws:codeconnections:region:account-id:connection/connection-id"
    }
  ]
}
```

Lihat [Konfigurasikan akses repositori](argocd-configure-repositories.md) untuk detail tentang penggunaan integrasi ini.

## Langkah selanjutnya
<a name="_next_steps"></a>
+  [Bekerja dengan Argo CD](working-with-argocd.md)- Pelajari cara membuat aplikasi dan mengelola penerapan
+  [Konsep Argo CD](argocd-concepts.md)- Memahami konsep Argo CD termasuk Proyek
+  [Pertimbangan keamanan untuk Kemampuan EKS](capabilities-security.md)- Tinjau praktik terbaik keamanan untuk kemampuan