Gunakan Managed Service for OpenTelemetry untuk melacak aplikasi di dalam dan di luar instance ASM - Alibaba Cloud Service Mesh

Service Mesh (ASM) mendukung pelacakan aplikasi yang diterapkan di dalam instance ASM. Untuk melacak aplikasi baik di dalam maupun di luar instance ASM secara bersamaan, Anda perlu menggunakan Managed Service for OpenTelemetry untuk menghasilkan jejak panggilan. Topik ini menjelaskan cara menggunakan Managed Service for OpenTelemetry agar aplikasi eksternal dapat memanggil aplikasi di dalam instance ASM, sehingga menghasilkan jejak panggilan antara kedua aplikasi tersebut.

Prasyarat

Instance Service Mesh (ASM) telah dibuat dan klaster ACK telah ditambahkan ke instance ASM. Untuk informasi lebih lanjut, lihat Buat Instance ASM dan Tambahkan Klaster ke Instance ASM.
Gateway masuk telah diterapkan untuk instance ASM guna memungkinkan akses eksternal ke aplikasi di dalam instance ASM. Untuk informasi lebih lanjut, lihat Buat Gateway Masuk.
Python 2.7 telah diinstal di lingkungan runtime tempat Anda ingin menerapkan aplikasi di luar instance ASM.
Managed Service for OpenTelemetry telah diaktifkan. Untuk informasi lebih lanjut, lihat Konfigurasikan dan Laporkan Data Pelacakan ASM.

Catatan penggunaan

Dalam contoh ini, aplikasi ExternalProxy yang dikompilasi menggunakan Python diterapkan di luar instance ASM. ExternalProxy menggunakan server HTTP. Ketika jalur root dari ExternalProxy diakses, server HTTP memanggil mikro layanan Productpage dari aplikasi Bookinfo yang diterapkan di dalam instance ASM.
Dalam contoh ini, Managed Service for OpenTelemetry digunakan untuk melacak aplikasi. Jika Anda menggunakan sistem pelacakan kustom yang kompatibel dengan Zipkin, lewati Langkah 2: Dapatkan Titik Akhir untuk Mengakses Managed Service for OpenTelemetry dan lanjutkan ke Langkah 3: Terapkan Aplikasi ExternalProxy. Atur titik akhir untuk akses eksternal ke sistem pelacakan kustom sebagai titik akhir ke mana data pelacakan dilaporkan.

Langkah 1: Terapkan aplikasi Bookinfo di dalam instance ASM

Jalankan perintah berikut untuk menerapkan aplikasi Bookinfo di klaster ACK yang telah ditambahkan ke instance ASM.
Anda dapat mengunduh file YAML aplikasi Bookinfo dari GitHub.
```
kubectl --kubeconfig=${DATA_PLANE_KUBECONFIG} apply -f bookinfo.yaml
```
Jalankan perintah berikut untuk menerapkan layanan virtual untuk aplikasi Bookinfo.
Anda dapat mengunduh file YAML layanan virtual dari GitHub.
```
kubectl --kubeconfig=${ASM_KUBECONFIG} apply -f virtual-service-all-v1.yaml
```
Jalankan perintah berikut untuk menerapkan aturan tujuan untuk aplikasi Bookinfo.
Anda dapat mengunduh file YAML aturan tujuan dari GitHub.
```
kubectl --kubeconfig=${ASM_KUBECONFIG} apply -f destination-rule-all.yaml
```
Jalankan perintah berikut untuk menerapkan gateway untuk aplikasi Bookinfo.
Anda dapat mengunduh file YAML gateway dari GitHub.
```
kubectl --kubeconfig=${ASM_KUBECONFIG} apply -f bookinfo-gateway.yaml
```

Langkah 2: Dapatkan titik akhir yang digunakan untuk mengakses Managed Service for OpenTelemetry

Masuk ke konsol Managed Service for OpenTelemetry. Di panel navigasi sisi kiri, klik Overview.
Di halaman Overview, klik tab Access process, lalu klik View access point information.
Lihat titik akhir akses.
1. Di bagian atas halaman, pilih wilayah yang sesuai.
  Pilih wilayah klaster ACK tempat aplikasi Bookinfo diterapkan. Memilih wilayah lain akan menyebabkan data pelacakan aplikasi Bookinfo tidak dapat dilaporkan ke Managed Service for OpenTelemetry.
2. Di tab Access point information, aktifkan Show Token untuk parameter Informasi Klaster. Pilih titik akhir publik atau pribadi berdasarkan lokasi penerapan aplikasi ExternalProxy.
  Dalam contoh ini, data pelacakan ExternalProxy dilaporkan menggunakan API Zipkin V1. Oleh karena itu, Anda harus menggunakan titik akhir publik atau pribadi Zipkin V1.

Langkah 3: Terapkan aplikasi ExternalProxy

Penting

Proxy sidecar meneruskan semua konten (termasuk header permintaan HTTP dan badan permintaan) yang diterima dalam permintaan ke layanan upstream. Oleh karena itu, header terkait pelacakan juga diteruskan ke layanan upstream.
Untuk meneruskan informasi pelacakan, aplikasi harus meneruskan header permintaan terkait pelacakan ke layanan upstream sesuai dengan spesifikasi komunitas Istio.

Buat file ExternalProxy.py yang berisi konten berikut dan simpan file tersebut di lingkungan runtime aplikasi ExternalProxy.

Ganti {XTRACE_ZIPKIN_V1_ENDPOINT} dengan titik akhir yang Anda peroleh di Langkah 2. Jika Anda perlu melaporkan data pelacakan ke sistem pelacakan kustom, ganti variabel tersebut dengan titik akhir akses sistem pelacakan kustom.

Ganti {INGRESS_GATE_WAY_IP} dengan titik akhir gateway masuk yang diterapkan untuk klaster ACK.

Tampilkan File ExternalProxy.py

import requests
from flask import Flask
from py_zipkin.zipkin import zipkin_span,create_http_headers_for_new_span
from py_zipkin.util import generate_random_64bit_string
from py_zipkin.util import ZipkinAttrs
import time

app = Flask(__name__)

def do_stuff(trace_id, span_id, parent_span_id):
    time.sleep(2)
    headers = create_http_headers_for_new_span()
    headers["X-B3-TraceId"] = trace_id
    headers["X-B3-SpanId"] = span_id
    headers["X-B3-ParentSpanId"] = parent_span_id
    print "SEND TO INGRESS HEADERS : {0}".format(headers)
    r = requests.get('http://${INGRESS_GATE_WAY_IP}/productpage', headers=headers)
    return 'OK'


def http_transport(encoded_span):
    # encoding prefix explained in https://github.com/Yelp/py_zipkin#transport
    body=encoded_span
    zipkin_url="${XTRACE_ZIPKIN_V1_ENDPOINT}"
    headers = {"Content-Type": "application/x-thrift"}

    # You'd probably want to wrap this in a try/except in case POSTing fails
    r=requests.post(zipkin_url, data=body, headers=headers)
    print(body)


@app.route('/')
def index():
    with zipkin_span(
        service_name='external-proxy',
        span_name='external-proxy/inbound',
        transport_handler=http_transport,
        port=5000,
        sample_rate=100, 
    ) as inbound_span:
    do_stuff(inbound_span.zipkin_attrs.trace_id, inbound_span.zipkin_attrs.span_id, inbound_span.zipkin_attrs.parent_span_id)

    return 'OK', 200

if __name__=='__main__':
    app.run(host="0.0.0.0",port=5000,debug=True)

Jalankan perintah berikut untuk memulai ExternalProxy:

python ExternalProxy.py

 * Serving Flask app "main" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 317-792-686

Jalankan perintah berikut untuk memanggil ExternalProxy:
```
curl localhost:5000
```
Keluaran yang diharapkan:
```
OK
```

Langkah 4: Lihat data pelacakan

Masuk ke konsol Managed Service for OpenTelemetry.
Di panel navigasi sisi kiri, klik Applications. Di bagian atas halaman Aplikasi, pilih wilayah tempat klaster ACK berada. Lalu, klik ExternalProxy di daftar aplikasi.
Di halaman yang muncul, klik Application Details di panel navigasi sisi kiri. Di halaman Detail Aplikasi, klik tab Traces. Lalu, klik ID jejak dari jejak panggilan yang ingin Anda kueri.
Jejak panggilan dihasilkan antara aplikasi ExternalProxy yang diterapkan di luar instance ASM dan aplikasi Bookinfo yang diterapkan di dalam instance ASM.