

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

# Aktifkan aplikasi Anda di Kubernetes
<a name="CloudWatch-Application-Signals-Enable-KubernetesMain"></a>

Aktifkan CloudWatch Application Signals di Kubernetes dengan menggunakan langkah-langkah pengaturan kustom yang dijelaskan di bagian ini.

Untuk aplikasi yang berjalan di Kubernetes, Anda menginstal dan mengkonfigurasi CloudWatch agen dan AWS Distro untuk Anda sendiri. OpenTelemetry Pada arsitektur ini yang diaktifkan dengan pengaturan Sinyal Aplikasi, Sinyal Aplikasi tidak secara otomatis menemukan nama layanan Anda atau klaster atau host tempat berjalannya. Anda harus menentukan nama-nama ini selama melakukan pengaturan kustom, dan nama yang Anda tentukan adalah apa yang akan ditampilkan pada dasbor Sinyal Aplikasi.

**Persyaratan**
+ Anda memiliki izin admininstrator di klaster Kubernetes tempat Anda mengaktifkan Sinyal Aplikasi.
+ Anda harus AWS CLI menginstal di lingkungan tempat cluster Kubernetes Anda berjalan. Untuk informasi selengkapnya tentang [menginstal AWS CLI, lihat Menginstal atau memperbarui versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Anda telah menginstal kubectl dan helm di terminal lokal Anda. [Untuk informasi selengkapnya, lihat dokumentasi [kubectl dan Helm](https://kubernetes.io/docs/tasks/tools/#kubectl).](https://helm.sh/)

## Langkah 1: Mengaktifkan Sinyal Aplikasi di akun Anda
<a name="CloudWatch-Application-Signals-Kubernetes"></a>

Anda harus terlebih dahulu mengaktifkan Sinyal Aplikasi di akun Anda. Jika belum, lihat[Aktifkan Sinyal Aplikasi di akun Anda](CloudWatch-Application-Signals-Enable.md).

## Langkah 2: Instal operator CloudWatch agen di cluster Anda
<a name="Application-Signals-Enable-Kubernetes-agent"></a>

Memasang operator CloudWatch agen akan menginstal operator, CloudWatch agen, dan instrumentasi otomatis lainnya ke dalam klaster Anda. Untuk melakukan hal itu, masukkan perintah berikut. Ganti *\$1REGION* dengan AWS wilayah Anda. Ganti *\$1YOUR\$1CLUSTER\$1NAME* dengan nama yang ingin Anda tampilkan untuk cluster Anda di dasbor Sinyal Aplikasi.

```
helm repo add aws-observability https://aws-observability.github.io/helm-charts
helm install amazon-cloudwatch-operator aws-observability/amazon-cloudwatch-observability \
--namespace amazon-cloudwatch --create-namespace \
--set region=$REGION \
--set clusterName=$YOUR_CLUSTER_NAME
```

Untuk informasi lebih lanjut, lihat [ amazon-cloudwatch-observability](https://github.com/aws-observability/helm-charts/tree/main/charts/amazon-cloudwatch-observability)di GitHub.

## Langkah 3: Siapkan AWS kredensyal untuk klaster Kubernetes Anda
<a name="Application-Signals-Enable-Kubernetes-credentials"></a>

**penting**  
Jika klaster Kubernetes Anda di-host di Amazon EC2, Anda dapat melewati bagian ini dan melanjutkan ke. [Langkah 4: Tambahkan anotasi](#Application-Signals-Enable-Kubernetes-annotations)

Jika klaster Kubernetes Anda di-host secara lokal, Anda harus menggunakan instruksi di bagian ini untuk menambahkan AWS kredensil ke lingkungan Kubernetes Anda.

**Untuk menyiapkan izin untuk klaster Kubernetes lokal**

1. Buat pengguna IAM yang akan digunakan untuk memberikan izin ke host lokal Anda:

   1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. Pilih **Pengguna**, **Buat Pengguna**.

   1. Dalam **detail Pengguna**, untuk **Nama pengguna**, masukkan nama untuk pengguna IAM baru. Ini adalah nama masuk AWS yang akan digunakan untuk mengautentikasi host Anda. Lalu pilih **Selanjutnya**

   1. Pada halaman **Setel izin**, di bawah **opsi Izin**, pilih **Lampirkan kebijakan** secara langsung.

   1. Dari daftar **Kebijakan izin**, pilih **CloudWatchAgentServerPolicy**kebijakan yang akan ditambahkan ke pengguna Anda. Lalu pilih **Selanjutnya**.

   1. Pada halaman **Tinjau dan buat**, pastikan bahwa Anda puas dengan nama pengguna dan **CloudWatchAgentServerPolicy**kebijakan tersebut ada di **ringkasan Izin**.

   1. Pilih **Buat pengguna**

1. Buat dan ambil kunci AWS akses dan kunci rahasia Anda:

   1. Di panel navigasi di konsol IAM, pilih **Pengguna** dan kemudian pilih nama pengguna pengguna yang Anda buat di langkah sebelumnya.

   1.  Pada halaman pengguna, pilih tab **Security credentials.** Kemudian, di bagian **Kunci akses**, pilih **Buat kunci akses**.

   1. Untuk **Buat tombol akses Langkah 1**, pilih **Antarmuka Baris Perintah (CLI)**.

   1. Untuk **Buat kunci akses Langkah 2**, secara opsional masukkan tag dan kemudian pilih **Berikutnya**.

   1. Untuk **Buat kunci akses Langkah 3**, pilih **Unduh file.csv untuk menyimpan file.csv** dengan kunci akses pengguna IAM dan kunci akses rahasia Anda. Anda memerlukan informasi ini untuk langkah selanjutnya.

   1. Pilih **Selesai**.

1. Konfigurasikan AWS kredensyal Anda di host lokal Anda dengan memasukkan perintah berikut. Ganti *ACCESS\$1KEY\$1ID* dan *SECRET\$1ACCESS\$1ID* dengan kunci akses yang baru dibuat dan kunci akses rahasia dari file.csv yang Anda unduh di langkah sebelumnya. Secara default, file kredensi disimpan di `/home/user/.aws/credentials.`

   ```
   $ aws configure --profile AmazonCloudWatchAgent
   AWS Access Key ID [None]: ACCESS_KEY_ID
   AWS Secret Access Key [None]: SECRET_ACCESS_ID
   Default region name [None]: MY_REGION
   Default output format [None]: json
   ```

1. Edit sumber daya kustom yang diinstal CloudWatch agen menggunakan bagan Helm untuk menambahkan rahasia AWS kredensil yang baru dibuat.

   ```
   kubectl edit amazoncloudwatchagent cloudwatch-agent -n amazon-cloudwatch
   ```

1. Saat editor file Anda terbuka, pasang AWS kredensil ke wadah CloudWatch agen dengan menambahkan konfigurasi berikut ke bagian atas penerapan. Ganti jalur `/home/user/.aws/credentials` dengan lokasi file AWS kredensyal lokal Anda.

   ```
   apiVersion: cloudwatch.aws.amazon.com/v1alpha1
   kind: AmazonCloudWatchAgent
   metadata:
     name: cloudwatch-agent
     namespace: amazon-cloudwatch
   spec:
     volumeMounts:
     - mountPath: /rootfs
       volumeMounts:
       - name: aws-credentials
         mountPath: /root/.aws
         readOnly: true
       volumes:
       - hostPath:
         path: /home/user/.aws/credentials
       name: aws-credentials
   ---
   ```

## Langkah 4: Tambahkan anotasi
<a name="Application-Signals-Enable-Kubernetes-annotations"></a>

**catatan**  
Jika Anda mengaktifkan Sinyal Aplikasi untuk aplikasi Node.js dengan ESM, lewati langkah-langkah di bagian ini dan lihat [Menyiapkan aplikasi Node.js dengan format modul ESM](#Kubernetes-NodeJs-ESM) saja.

[https://kubernetes.io/docs/concepts/workloads/](https://kubernetes.io/docs/concepts/workloads/) Anotasi ini menginstruksikan aplikasi Anda secara otomatis untuk mengirim metrik, jejak, dan log ke Sinyal Aplikasi.

**Untuk menambahkan anotasi untuk Sinyal Aplikasi**

1. Anda memiliki dua pilihan untuk keterangan:
   + **Beri anotasi pada instrumen otomatis Beban Kerja satu beban** kerja dalam sebuah klaster.
   + **Beri Keterangan Namespace** secara otomatis melengkapi semua beban kerja yang di-deploy di namespace yang dipilih.

   Pilih salah satu opsi tersebut, dan ikuti langkah-langkah yang sesuai.

1. Untuk membuat anotasi satu beban kerja, masukkan salah satu perintah berikut. Ganti *\$1WORKLOAD\$1TYPE* dan *\$1WORKLOAD\$1NAME* dengan nilai untuk beban kerja Anda.
   + Untuk beban kerja Java:

     ```
     kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-java": "true"}}}}}'
     ```
   + Untuk beban kerja Python:

     ```
     kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-python": "true"}}}}}'
     ```

     Untuk aplikasi Python, ada konfigurasi tambahan yang diperlukan. Untuk informasi selengkapnya, lihat [Aplikasi Python tidak dimulai setelah Sinyal Aplikasi diaktifkan](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-starting-Python).
   + Untuk beban kerja.NET:

     ```
     kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-dotnet": "true"}}}}}'
     ```
**catatan**  
Untuk mengaktifkan Sinyal Aplikasi untuk beban kerja.NET pada gambar berbasis Alpine Linux (`linux-musl-x64`), tambahkan anotasi tambahan berikut.  

     ```
     instrumentation.opentelemetry.io/otel-dotnet-auto-runtime: "linux-musl-x64"
     ```
   + Untuk beban kerja Node.js:

     ```
     kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-nodejs": "true"}}}}}'
     ```

1. Untuk membuat anotasi semua beban kerja di namespace, masukkan masukkan salah satu perintah berikut. Ganti *\$1NAMESPACE* dengan nama namespace Anda.

   Jika namespace menyertakan beban kerja Java, Python, dan .NET, tambahkan semua anotasi ke namespace.
   + Untuk beban kerja Java di namespace:

     ```
     kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-java=true
     ```
   + Untuk beban kerja Python di namespace:

     ```
     kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-python=true
     ```

     Untuk aplikasi Python, ada konfigurasi tambahan yang diperlukan. Untuk informasi selengkapnya, lihat [Aplikasi Python tidak dimulai setelah Sinyal Aplikasi diaktifkan](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-starting-Python).
   + Untuk beban kerja.NET di namespace:

     ```
     kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-dotnet=true
     ```
   + Untuk beban kerja Node.js di namespace:

     ```
     kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-nodejs=true
     ```

   Setelah menambahkan anotasi, restart semua pod di namespace dengan memasukkan perintah berikut:

   ```
   kubectl rollout restart
   ```

1. Ketika langkah-langkah sebelumnya selesai, di CloudWatch konsol, pilih **Sinyal Aplikasi**, **Layanan**. Ini membuka dasbor tempat Anda dapat melihat data yang dikumpulkan oleh Sinyal Aplikasi. Mungkin diperlukan waktu beberapa menit hingga akhirnya data muncul.

   Untuk informasi selengkapnya tentang tampilan **Layanan**, silakan lihat [Memantau kondisi kesehatan operasional aplikasi Anda dengan Sinyal Aplikasi](Services.md).

### Menyiapkan aplikasi Node.js dengan format modul ESM
<a name="Kubernetes-NodeJs-ESM"></a>

Kami menyediakan dukungan terbatas untuk aplikasi Node.js dengan format modul ESM. Lihat perinciannya di [Keterbatasan yang diketahui tentang Node.js dengan ESM](CloudWatch-Application-Signals-supportmatrix.md#ESM-limitations).

Untuk format modul ESM, mengaktifkan Sinyal Aplikasi dengan membuat anotasi file manifes tidak berfungsi. Lewati prosedur sebelumnya dan lakukan hal berikut sebagai gantinya:

**Untuk mengaktifkan Sinyal Aplikasi untuk aplikasi Node.js dengan ESM**

1. Instal dependensi yang relevan ke aplikasi Node.js Anda untuk autoinstrumentasi:

   ```
   npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation
   npm install @opentelemetry/instrumentation@0.54.0
   ```

1. Tambahkan variabel lingkungan berikut ke Dockerfile untuk aplikasi Anda dan buat gambar.

   ```
   ...
   ENV OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true
   ENV OTEL_TRACES_SAMPLER_ARG='endpoint=http://cloudwatch-agent.amazon-cloudwatch:2000'
   ENV OTEL_TRACES_SAMPLER='xray'
   ENV OTEL_EXPORTER_OTLP_PROTOCOL='http/protobuf'
   ENV OTEL_EXPORTER_OTLP_TRACES_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/traces'
   ENV OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/metrics'
   ENV OTEL_METRICS_EXPORTER='none'
   ENV OTEL_LOGS_EXPORTER='none'
   ENV NODE_OPTIONS='--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs'
   ENV OTEL_SERVICE_NAME='YOUR_SERVICE_NAME' #replace with a proper service name
   ENV OTEL_PROPAGATORS='tracecontext,baggage,b3,xray'
   ...
   
   # command to start the application
   # for example
   # CMD ["node", "index.mjs"]
   ```

1. Tambahkan variabel lingkungan`OTEL_RESOURCE_ATTRIBUTES_POD_NAME`,`OTEL_RESOURCE_ATTRIBUTES_NODE_NAME`,`OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME`, `POD_NAMESPACE` dan `OTEL_RESOURCE_ATTRIBUTES` ke file yaml penerapan untuk aplikasi. Contoh:

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nodejs-app
     labels:
       app: nodejs-app
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: nodejs-app
     template:
       metadata:
         labels:
           app: nodejs-app
         # annotations:
         # make sure this annotation doesn't exit
         #   instrumentation.opentelemetry.io/inject-nodejs: 'true'
       spec:
         containers:
         - name: nodejs-app
           image:your-nodejs-application-image #replace it with a proper image uri
           imagePullPolicy: Always
           ports:
           - containerPort: 8000
           env:
             - name: OTEL_RESOURCE_ATTRIBUTES_POD_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.name
             - name: OTEL_RESOURCE_ATTRIBUTES_NODE_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: spec.nodeName
             - name: OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.labels['app'] # Assuming 'app' label is set to the deployment name
             - name: POD_NAMESPACE
               valueFrom:
                 fieldRef:
                   fieldPath: metadata.namespace
             - name: OTEL_RESOURCE_ATTRIBUTES
               value: "k8s.deployment.name=$(OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME),k8s.namespace.name=$(POD_NAMESPACE),k8s.node.name=$(OTEL_RESOURCE_ATTRIBUTES_NODE_NAME),k8s.pod.name=$(OTEL_RESOURCE_ATTRIBUTES_POD_NAME)"
   ```

1. Menerapkan aplikasi Node.js ke cluster Kubernetes.

## (Opsional) Langkah 5: Pantau kesehatan aplikasi Anda
<a name="CloudWatch-Application-Signals-Monitor-Kubernetes"></a>

Setelah Anda mengaktifkan aplikasi di Kubernetes, Anda dapat memantau kesehatan aplikasi Anda. Lihat informasi yang lebih lengkap di [Memantau kondisi kesehatan operasional aplikasi Anda dengan Sinyal Aplikasi](Services.md).