วิธีตรวจสอบ

เอกสารนี้อธิบายเทคนิคการตรวจสอบคอมโพเนนต์ที่ภายในองค์กรรองรับ การติดตั้งใช้งาน Apigee Edge สำหรับ Private Cloud

ภาพรวม

Edge รองรับหลายวิธีในการดูรายละเอียดเกี่ยวกับบริการต่างๆ ตลอดจนตรวจสอบ สถานะ ตารางต่อไปนี้แสดงประเภทการตรวจสอบที่คุณจะทำได้กับแต่ละรายการที่มีสิทธิ์ บริการ:

Mgmt API
ส่วนประกอบ การใช้หน่วยความจำ [JMX*] การตรวจสอบบริการ สถานะผู้ใช้/องค์กร/ การทำให้ใช้งานได้ สถานะแอกซ์สถานะ การตรวจสอบฐานข้อมูล สถานะ apigee-service apigee-monit**
เซิร์ฟเวอร์การจัดการ
Message Processor
เราเตอร์
Qpid
Postgres
ข้อมูลเพิ่มเติม ข้อมูลเพิ่มเติม ข้อมูลเพิ่มเติม ข้อมูลเพิ่มเติม ข้อมูลเพิ่มเติม ข้อมูลเพิ่มเติม ข้อมูลเพิ่มเติม

* ก่อนที่คุณจะสามารถใช้ JMX คุณต้องเปิดใช้ ตามที่อธิบายไว้ใน เปิดใช้งาน JMX

** บริการ apigee-monit จะตรวจสอบว่าคอมโพเนนต์ทำงานหรือไม่และจะพยายาม ถ้าไม่เปิดใหม่ สำหรับข้อมูลเพิ่มเติม โปรดดูการรักษาด้วยตนเองด้วย apigee-monit

การตรวจสอบพอร์ตและไฟล์การกำหนดค่า

คอมโพเนนต์แต่ละอย่างรองรับการเรียกใช้ Java Management Extensions (JMX) และ Management API พอร์ตต่างๆ ตารางต่อไปนี้แสดงพอร์ต JMX และ Management API สำหรับเซิร์ฟเวอร์แต่ละประเภท และ ตำแหน่งไฟล์การกำหนดค่า:

ส่วนประกอบ พอร์ต JMX พอร์ต API การจัดการ ตำแหน่งไฟล์การกำหนดค่า
เซิร์ฟเวอร์การจัดการ 1099 8080 $APIGEE_ROOT/customer/application/management-server.properties
Message Processor 1101 8082 $APIGEE_ROOT/customer/application/message-processor.properties
เราเตอร์ 1100 8081 $APIGEE_ROOT/customer/application/router.properties
Qpid 1102 8083 $APIGEE_ROOT/customer/application/qpid-server.properties
Postgres 1103 8084 $APIGEE_ROOT/customer/application/postgres-server.properties

ใช้ JMX เพื่อตรวจสอบคอมโพเนนต์

ส่วนต่อไปนี้จะอธิบายวิธีใช้ JMX เพื่อตรวจสอบคอมโพเนนต์ Edge

เปิดใช้ JMX

หากต้องการเปิดใช้ JMX โดยไม่มีการตรวจสอบสิทธิ์หรือการสื่อสารที่ใช้ SSL ให้ทำตามขั้นตอนด้านล่าง หมายเหตุ: ในระบบที่ใช้งานจริง ควรเปิดใช้ทั้งการตรวจสอบสิทธิ์ที่เข้ารหัสและ SSL

  1. แก้ไขไฟล์การกำหนดค่าที่เหมาะสม (โปรดดู การอ้างอิงไฟล์การกำหนดค่า) สร้างไฟล์การกำหนดค่า หากยังไม่มี 
    conf_system_jmxremote_enable=true
  2. บันทึกไฟล์การกำหนดค่าและตรวจสอบว่าไฟล์เป็นของ apigee:apigee
  3. รีสตาร์ทคอมโพเนนต์ Edge ที่เหมาะสม 
    apigee-service edge-management-server restart

หากต้องการปิดใช้ JMX ให้นำพร็อพเพอร์ตี้ conf_system_jmxremote_enable ออกหรือเปลี่ยน เป็น false จากนั้นรีสตาร์ทคอมโพเนนต์ Edge ที่เหมาะสม

การตรวจสอบสิทธิ์ใน JMX

Edge สำหรับ Private Cloud รองรับการตรวจสอบสิทธิ์ด้วยรหัสผ่านโดยใช้รายละเอียดที่จัดเก็บไว้ในไฟล์ คุณสามารถจัดเก็บรหัสผ่านเป็นแฮชเพื่อเพิ่มความปลอดภัย

  1. หากต้องการเปิดใช้การตรวจสอบสิทธิ์ JMX ในคอมโพเนนต์ EDGE-* ให้แก้ไขไฟล์การกำหนดค่าที่เหมาะสม (โปรดดู การอ้างอิงไฟล์การกำหนดค่า) สร้างไฟล์การกำหนดค่าหากไม่มีไฟล์อยู่ โดยทำดังนี้ 
    conf_system_jmxremote_enable=true
conf_system_jmxremote_authenticate=true
conf_system_jmxremote_encrypted_auth=true
conf_system_jmxremote_access_file=/opt/apigee/customer/application/management-server/jmxremote.access
conf_system_jmxremote_password_file=/opt/apigee/customer/application/management-server/jmxremote.password
     บันทึกไฟล์การกำหนดค่าและตรวจสอบว่า apigee:apigee เป็นเจ้าของไฟล์ดังกล่าว
  2. สร้างแฮช SHA256 ของรหัสผ่าน 
    echo -n '' | openssl dgst -sha256
  3. สร้างไฟล์ jmxremote.password ด้วยข้อมูลเข้าสู่ระบบของผู้ใช้ JMX
    1. คัดลอกไฟล์ต่อไปนี้จากไดเรกทอรี $JAVA_HOME ไปยัง ไดเรกทอรี /opt/apigee/customer/application/<component>/: 
      cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/management-server/jmxremote.password
    2. แก้ไขไฟล์และเพิ่มชื่อผู้ใช้และรหัสผ่าน JMX ของคุณโดยใช้ไวยากรณ์ต่อไปนี้ 
      USERNAME <HASH-PASSWORD>
    3. ตรวจสอบว่า apigee เป็นเจ้าของไฟล์นี้และโหมดไฟล์เป็น 400 
      chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password
chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.password
  4. สร้างไฟล์ jmxremote.access ที่มีสิทธิ์ของผู้ใช้ JMX
    1. คัดลอกไฟล์ต่อไปนี้จากไดเรกทอรี $JAVA_HOME ของคุณไปที่ ไดเรกทอรี /opt/apigee/customer/application/<component>/ 
      
cp ${JAVA_HOME}/lib/management/jmxremote.access$APIGEE_ROOT/customer/application/management-server/jmxremote.password/jmxremote.access
    2. แก้ไขไฟล์และเพิ่มชื่อผู้ใช้ JMX ของคุณ ตามด้วยสิทธิ์ (READONLY/READWRITE) 
      USERNAME READONLY
    3. ตรวจสอบว่า apigee เป็นเจ้าของไฟล์นี้และโหมดไฟล์เป็น 400 
      chown apigee:apigee $APIGEE_ROOT/customer/application/management-server/jmxremote.password

chmod 400 $APIGEE_ROOT/customer/application/management-server/jmxremote.access
  5. รีสตาร์ทคอมโพเนนต์ Edge ที่เหมาะสมดังนี้ 
    apigee-service edge-management-server restart

หากต้องการปิดใช้การตรวจสอบสิทธิ์ JMX ให้นำพร็อพเพอร์ตี้ออก conf_system_jmxremote_authenticateหรือเปลี่ยนค่าเป็น false และ รีสตาร์ทคอมโพเนนต์ Edge ที่เหมาะสม

SSL ใน JMX

วิธีเปิดใช้ JMX ที่ใช้ SSL ในคอมโพเนนต์ edge-*

  1. แก้ไขไฟล์การกำหนดค่าที่เหมาะสม (โปรดดู การอ้างอิงไฟล์การกำหนดค่า) สร้างไฟล์การกำหนดค่าหากไม่มีไฟล์อยู่ โดยทำดังนี้ 
    conf_system_jmxremote_enable=true
conf_system_jmxremote_ssl=true
conf_system_javax_net_ssl_keystore=/opt/apigee/customer/application/management-server/jmxremote.keystore
conf_system_javax_net_ssl_keystorepassword=<keystore-password>
     บันทึกไฟล์การกำหนดค่าและตรวจสอบว่า apigee:apigee เป็นเจ้าของไฟล์ดังกล่าว
  2. เตรียมคีย์สโตร์ที่มีคีย์เซิร์ฟเวอร์และวางไว้ในเส้นทางที่ระบุไว้ใน conf_system_javax_net_ssl_keystore ข้างต้น ตรวจสอบว่าไฟล์คีย์สโตร์ apigee:apigee สามารถอ่านได้
  3. รีสตาร์ทคอมโพเนนต์ Edge ที่เหมาะสมดังนี้ 
    apigee-service edge-management-server restart

หากต้องการปิดใช้ JMX ที่ใช้ SSL ให้นำพร็อพเพอร์ตี้ conf_system_jmxremote_ssl ออก หรือเปลี่ยนค่าเป็น false รีสตาร์ทคอมโพเนนต์ Edge ที่เหมาะสม

การตรวจสอบผ่าน Jconsole

วิธีการตรวจสอบผ่าน jconsole ยังคงเหมือนเดิมตามที่อธิบายไว้ใน https://docs.apigee.com/private-cloud/v4.52.01/how-monitor#jconsole.

โดยสามารถเพิ่มบรรทัดหนึ่งว่า "jconsole จะต้องเริ่มต้นด้วย Truststore และ Truststore รหัสผ่านในกรณีที่เปิดใช้ SSL สำหรับ JMX" ข้อมูลอ้างอิง: https://docs.oracle.com/javase/8/docs/technotes/guides/management/jconsole.html

ตรวจสอบด้วย JConsole

ใช้ JConsole (เครื่องมือที่เป็นไปตามมาตรฐาน JMX) เพื่อจัดการและตรวจสอบการตรวจสอบประสิทธิภาพการทำงานและประมวลผลสถิติ เมื่อใช้ JConsole คุณสามารถใช้สถิติ JMX ที่เปิดเผยไว้โดยเซิร์ฟเวอร์ และแสดงสถิติใน อินเทอร์เฟซแบบกราฟิก สำหรับข้อมูลเพิ่มเติม โปรดดู การใช้ JConsole

คุณต้องเริ่มต้น JConsole ด้วย Truststore และ Truststore เมื่อมีการเปิดใช้งาน SSL สำหรับ JMX โปรดดู ใช้ JConsole

JConsole ใช้ URL บริการต่อไปนี้เพื่อตรวจสอบแอตทริบิวต์ JMX (MBeans) ที่ให้บริการผ่าน JMX:

service:jmx:rmi:///jndi/rmi://IP_address:port_number/jmxrmi

สถานที่:

  • IP_address คือที่อยู่ IP ของเซิร์ฟเวอร์ที่คุณต้องการตรวจสอบ
  • port_number คือหมายเลขพอร์ต JMX ของเซิร์ฟเวอร์ที่คุณต้องการ จอภาพ

ตัวอย่างเช่น ในการตรวจสอบเซิร์ฟเวอร์การจัดการ ให้ออกคำสั่งดังต่อไปนี้ (สมมติว่า ที่อยู่ IP ของเซิร์ฟเวอร์คือ 216.3.128.12):

service:jmx:rmi:///jndi/rmi://216.3.128.12:1099/jmxrmi

โปรดทราบว่าตัวอย่างนี้ระบุพอร์ต 1099 ซึ่งเป็นพอร์ต JMX ของเซิร์ฟเวอร์การจัดการ สำหรับ โปรดดูพอร์ตการตรวจสอบ JMX และ Management API

ตารางต่อไปนี้แสดงสถิติทั่วไปของ JMX

JMX MBeans แอตทริบิวต์ของ JMX

หน่วยความจำ

HeapMemoryUsage

NonHeapMemoryUsage

การใช้งาน

การอ้างอิงไฟล์การกำหนดค่า

ส่วนต่อไปนี้จะอธิบายการเปลี่ยนแปลงที่คุณอาจต้องทำกับการกำหนดค่าคอมโพเนนต์ Edge ไฟล์สำหรับการกำหนดค่าที่เกี่ยวข้องกับ JMX โปรดดู การตรวจสอบพอร์ตและไฟล์การกำหนดค่าสำหรับข้อมูลเพิ่มเติม

การกำหนดค่า JMX ที่จะเพิ่มไปยังไฟล์การกำหนดค่าของคอมโพเนนต์ที่เหมาะสม

  • เปิดใช้เอเจนต์ JMX ในคอมโพเนนต์ขอบ เท็จโดยค่าเริ่มต้น 
    conf_system_jmxremote_enable=true

การกำหนดค่าสำหรับการตรวจสอบสิทธิ์ด้วยรหัสผ่าน

  • เปิดใช้การตรวจสอบสิทธิ์ด้วยรหัสผ่าน เท็จโดยค่าเริ่มต้น 
    conf_system_jmxremote_authenticate=true
  • เส้นทางในการเข้าถึงไฟล์ ผู้ใช้ Apigee ควรเป็นเจ้าของและอ่านได้เท่านั้น 
    conf_system_jmxremote_access_file=/opt/apigee/customer/application/management-server/jmxremote.access
  • เส้นทางไปยังไฟล์รหัสผ่าน ผู้ใช้ Apigee ควรเป็นเจ้าของและอ่านได้เท่านั้น 
    conf_system_jmxremote_password_file=/opt/apigee/customer/application/management-server/jmxremote.password
  • เปิดใช้การจัดเก็บรหัสผ่านในรูปแบบที่เข้ารหัส เท็จโดยค่าเริ่มต้น 
    conf_system_jmxremote_encrypted_auth=true

การกำหนดค่าสำหรับ JMX ที่ใช้ SSL

  • เปิดใช้งาน SSL สำหรับการสื่อสาร JMX เท็จโดยค่าเริ่มต้น 
    conf_system_jmxremote_ssl=true
  • เส้นทางไปยังคีย์สโตร์ ผู้ใช้ Apigee ควรเป็นเจ้าของและอ่านได้เท่านั้น 
    conf_system_javax_net_ssl_keystore=/opt/apigee/customer/application/management-server/jmxremote.keystore
  • รหัสผ่านคีย์สโตร์: 
    conf_system_javax_net_ssl_keystorepassword=changeme

การกำหนดค่า JMX ที่ไม่บังคับ

ค่าที่แสดงเป็นค่าเริ่มต้นและเปลี่ยนแปลงได้

  • พอร์ต JMX ค่าเริ่มต้นแสดงอยู่ในตารางด้านล่าง 
    conf_system_jmxremote_port=
  • พอร์ต JMX RMI โดยค่าเริ่มต้น กระบวนการของ Java จะเลือกพอร์ตแบบสุ่ม 
    conf_system_jmxremote_rmi_port=
  • ชื่อโฮสต์สำหรับต้นขั้วระยะไกล ที่อยู่ IP เริ่มต้นของ localhost 
    conf_system_java_rmi_server_hostname=
  • ปกป้องรีจิสทรี JMX ด้วย SSL เท็จเริ่มต้น ใช้ได้เมื่อเปิดใช้ SSL เท่านั้น 
    conf_system_jmxremote_registry_ssl=false

ตรวจสอบด้วย Management API

Edge มี API หลายรายการที่คุณสามารถใช้เพื่อตรวจสอบบริการบนเซิร์ฟเวอร์ของคุณและ ตรวจสอบผู้ใช้ องค์กร และการติดตั้งใช้งาน ส่วนนี้อธิบายเกี่ยวกับ API เหล่านี้

ดำเนินการตรวจสอบบริการ

Management API มีอุปกรณ์ปลายทางจำนวนมากสำหรับการตรวจสอบและวิเคราะห์ปัญหาเกี่ยวกับ บริการต่างๆ โดยปลายทางเหล่านี้ ได้แก่

ปลายทาง คำอธิบาย
/servers/self/up

ตรวจสอบว่าบริการทำงานอยู่หรือไม่ คุณไม่จำเป็นต้องเรียกใช้ API นี้ ตรวจสอบสิทธิ์แล้ว

ถ้าบริการกำลังทำงาน ปลายทางนี้จะแสดงการตอบกลับต่อไปนี้

<ServerField>
  <Up>true</Up>
</ServerField>

หากบริการไม่ทำงาน คุณจะได้รับการตอบกลับที่คล้ายคลึงกับข้อความต่อไปนี้ (ขึ้นอยู่กับว่าเป็นบริการใดและคุณตรวจสอบอย่างไร):

curl: Failed connect to localhost:port_number; Connection refused
/servers/self

แสดงข้อมูลเกี่ยวกับบริการ ซึ่งรวมถึงข้อมูลต่อไปนี้

  • พร็อพเพอร์ตี้การกำหนดค่า
  • เวลาเริ่มต้นและเวลาสิ้นสุด
  • ข้อมูลบิลด์, RPM และ UUID
  • ชื่อโฮสต์และที่อยู่ IP ทั้งภายในและภายนอก
  • ภูมิภาคและพ็อด
  • พร็อพเพอร์ตี้ <isUp> ที่ระบุว่าบริการกำลังทำงานอยู่หรือไม่

การเรียก API นี้กำหนดให้คุณต้องตรวจสอบสิทธิ์ด้วยข้อมูลเข้าสู่ระบบของผู้ดูแลระบบ Apigee

หากต้องการใช้ปลายทางเหล่านี้ ให้เรียกใช้ยูทิลิตี เช่น curl ด้วยคำสั่งที่ใช้ ไวยากรณ์ต่อไปนี้:

curl http://host:port_number/v1/servers/self/up -H "Accept: [application/json|application/xml]"
curl http://host:port_number/v1/servers/self -u username:password -H "Accept: [application/json|application/xml]"

สถานที่:

  • host คือที่อยู่ IP ของเซิร์ฟเวอร์ที่คุณต้องการตรวจสอบ หากเข้าสู่ระบบ เซิร์ฟเวอร์ คุณสามารถใช้ "localhost" หรือไม่เช่นนั้น ให้ระบุที่อยู่ IP ของเซิร์ฟเวอร์ด้วย เป็นชื่อผู้ใช้และรหัสผ่าน
  • port_number คือพอร์ต Management API สำหรับเซิร์ฟเวอร์ที่คุณต้องการตรวจสอบ นี่คือ พอร์ตหนึ่งพอร์ตสำหรับคอมโพเนนต์แต่ละประเภท ตัวอย่างเช่น เซิร์ฟเวอร์การจัดการ พอร์ต API การจัดการคือ 8080 ดูรายการหมายเลขพอร์ต Management API ที่จะใช้ได้ที่ พอร์ตการตรวจสอบ JMX และ Management API

หากต้องการเปลี่ยนรูปแบบการตอบกลับ ให้ระบุส่วนหัว Accept เป็น &quot;application/json&quot; หรือ "application/xml"

ตัวอย่างต่อไปนี้จะดูสถานะเราเตอร์บน localhost (พอร์ต 8081)

curl http://localhost:8081/v1/servers/self/up -H "Accept: application/xml"

ตัวอย่างต่อไปนี้รับข้อมูลเกี่ยวกับ Message Processor ที่ 216.3.128.12 (พอร์ต 8082):

curl http://216.3.128.12:8082/v1/servers/self -u sysAdminEmail:password
  -H "Accept: application/xml"

ตรวจสอบสถานะผู้ใช้ องค์กร และการทำให้ใช้งานได้

คุณสามารถใช้ Management API เพื่อตรวจสอบสถานะผู้ใช้ องค์กร และการติดตั้งใช้งาน พร็อกซีในเซิร์ฟเวอร์การจัดการและผู้ประมวลผลข้อความด้วยการออกคำสั่งต่อไปนี้

curl http://host:port_number/v1/users -u sysAdminEmail:password
curl http://host:port_number/v1/organizations -u sysAdminEmail:password
curl http://host:port_number/v1/organizations/orgname/deployments -u sysAdminEmail:password

โดยที่ port_number จะเป็น 8080 สำหรับเซิร์ฟเวอร์การจัดการ หรือ 8082 สำหรับข้อความ ผู้ประมวลผลข้อมูล

การเรียกใช้นี้กำหนดให้คุณต้องตรวจสอบสิทธิ์ด้วยชื่อผู้ใช้ของผู้ดูแลระบบและ รหัสผ่าน

เซิร์ฟเวอร์ควรส่งคืนสถานะ "ทำให้ใช้งานได้แล้ว" สถานะสำหรับการโทรทั้งหมด หากล้มเหลว ให้ดำเนินการดังนี้

  1. ตรวจสอบบันทึกเซิร์ฟเวอร์เพื่อหาข้อผิดพลาด บันทึกจะอยู่ที่
    • เซิร์ฟเวอร์การจัดการ: opt/apigee/var/log/edge-management-server
    • ตัวประมวลผลข้อความ: opt/apigee/var/log/edge-message-processor
  2. เรียกเซิร์ฟเวอร์เพื่อตรวจสอบว่าทำงานได้อย่างถูกต้อง
  3. นำเซิร์ฟเวอร์ออกจาก ELB แล้วรีสตาร์ทเซิร์ฟเวอร์: 
    /opt/apigee/apigee-service/bin/apigee-service service_name restart

    โดยที่ service_name คือ

    • edge-management-server
    • edge-message-processor

ตรวจสอบสถานะด้วยคำสั่ง apigee-service

คุณแก้ปัญหาเกี่ยวกับบริการ Edge ได้โดยใช้คำสั่ง apigee-service เมื่อคุณ ลงชื่อเข้าใช้เซิร์ฟเวอร์ที่เรียกใช้บริการ

วิธีตรวจสอบสถานะของบริการด้วย apigee-service

  1. เข้าสู่ระบบเซิร์ฟเวอร์และเรียกใช้คำสั่งต่อไปนี้ 
    /opt/apigee/apigee-service/bin/apigee-service service_name status

    โดยที่ service_name คือค่าใดค่าหนึ่งต่อไปนี้

    • เซิร์ฟเวอร์การจัดการ: edge-management-server
    • ตัวประมวลผลข้อความ: edge-message-processor
    • Postgres: edge-postgres-server
    • QPID: edge-qpid-server
    • เราเตอร์: edge-router

    เช่น

    /opt/apigee/apigee-service/bin/apigee-service edge-message-processor status
  2. หากบริการไม่ได้ทำงานอยู่ ให้เริ่มต้นบริการโดยทำดังนี้ 
    /opt/apigee/apigee-service/bin/apigee-service service_name start
  3. หลังจากรีสตาร์ทบริการแล้ว ให้ตรวจสอบว่าบริการทำงานโดยใช้ คำสั่ง apigee-service status ที่คุณใช้ก่อนหน้านี้หรือใช้ Management API ตามที่อธิบายไว้ในหัวข้อตรวจสอบด้วย Management API

    เช่น

    curl -v http://localhost:port_number/v1/servers/self/up

    โดยที่ port_number คือพอร์ต Management API สำหรับบริการ

    ตัวอย่างนี้จะถือว่าคุณเข้าสู่ระบบเซิร์ฟเวอร์และสามารถใช้ "localhost" ได้ ในฐานะ ชื่อโฮสต์ หากต้องการตรวจสอบสถานะจากระยะไกลด้วย Management API คุณต้องระบุ IP ที่อยู่ของเซิร์ฟเวอร์และรวมชื่อผู้ใช้และรหัสผ่านของผู้ดูแลระบบใน API ของคุณ การโทร

การตรวจสอบ Postgres

Postgres รองรับยูทิลิตีหลายอย่างที่คุณใช้ในการตรวจสอบสถานะได้ ยูทิลิตีเหล่านี้ ซึ่งอธิบายไว้ในส่วนต่อๆ ไป

ตรวจสอบองค์กรและสภาพแวดล้อมใน Postgres

คุณสามารถตรวจสอบชื่อองค์กรและสภาพแวดล้อมที่เริ่มต้นใช้งานในเซิร์ฟเวอร์ Postgres ได้ ด้วยการออกคำสั่ง curl ต่อไปนี้

curl -v http://postgres_IP:8084/v1/servers/self/organizations

ระบบควรแสดงชื่อองค์กรและสภาพแวดล้อม

ยืนยันสถานะการวิเคราะห์

คุณสามารถยืนยันสถานะของเซิร์ฟเวอร์การวิเคราะห์ Postgres และ Qpid ได้โดยการออกข้อมูลต่อไปนี้ คำสั่ง curl:

curl -u userEmail:password http://host:port_number/v1/organizations/orgname/environments/envname/provisioning/axstatus

ระบบควรแสดงสถานะความสำเร็จสำหรับเซิร์ฟเวอร์การวิเคราะห์ทั้งหมด ตามตัวอย่างต่อไปนี้ แสดง:

{
  "environments" : [ {
    "components" : [ {
      "message" : "success at Thu Feb 28 10:27:38 CET 2013",
      "name" : "pg",
      "status" : "SUCCESS",
      "uuid" : "[c678d16c-7990-4a5a-ae19-a99f925fcb93]"
     }, {
      "message" : "success at Thu Feb 28 10:29:03 CET 2013",
      "name" : "qs",
      "status" : "SUCCESS",
      "uuid" : "[ee9f0db7-a9d3-4d21-96c5-1a15b0bf0adf]"
     } ],
    "message" : "",
    "name" : "prod"
   } ],
  "organization" : "acme",
  "status" : "SUCCESS"
}

ฐานข้อมูล PostgreSQL

ส่วนนี้จะอธิบายเทคนิคที่คุณใช้ตรวจสอบ Postgres โดยเฉพาะได้ ฐานข้อมูล

ใช้สคริปต์ check_postgres.pl

หากต้องการตรวจสอบฐานข้อมูล PostgreSQL คุณสามารถใช้สคริปต์การตรวจสอบมาตรฐาน check_postgres.pl สำหรับข้อมูลเพิ่มเติม โปรดดู http://bucardo.org/wiki/Check_postgres.

ก่อนเรียกใช้สคริปต์ ให้ทำดังนี้

  1. คุณต้องติดตั้งสคริปต์ check_postgres.pl บนโหนด Postgres แต่ละโหนด
  2. ตรวจสอบว่าคุณได้ติดตั้ง perl-Time-HiRes.x86_64 ซึ่งเป็นโมดูล Perl ที่ ใช้เครื่องตั้งเวลาสำหรับปลุก การนอนหลับ เวลาพักฟื้น และช่วงละครั้งที่มีความละเอียดสูง ตัวอย่างเช่น คุณสามารถ สามารถติดตั้งโดยใช้คำสั่งต่อไปนี้:
    yum install perl-Time-HiRes.x86_64
  3. CentOS 7: ก่อนใช้ check_postgres.pl ใน CentOS v7 ให้ติดตั้ง perl-Data-Dumper.x86_64 RPM

เอาต์พุต check_postgres.pl

เอาต์พุตเริ่มต้นของการเรียก API โดยใช้ check_postgres.pl คือ Nagios ที่เข้ากันได้ หลังจากติดตั้งสคริปต์แล้ว ให้ตรวจสอบต่อไปนี้

  1. ตรวจสอบขนาดของฐานข้อมูลดังนี้ 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -include=apigee -action database_size --warning='800 GB' --critical='900 GB'
  2. ตรวจสอบจำนวนการเชื่อมต่อขาเข้ากับฐานข้อมูลและเปรียบเทียบกับจำนวนสูงสุดที่อนุญาต การเชื่อมต่อ: 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action backends
  3. ตรวจสอบว่าฐานข้อมูลทำงานอยู่และพร้อมใช้งานหรือไม่ โดยทำดังนี้ 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action connection
  4. ตรวจสอบพื้นที่ในดิสก์โดยทำดังนี้ 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action disk_space --warning='80%' --critical='90%'
  5. ตรวจสอบจำนวนองค์กรและสภาพแวดล้อมที่เริ่มต้นใช้งานในโหนด Postgres ดังนี้ 
    check_postgres.pl -H 10.176.218.202 -db apigee -u apigee -dbpass postgres -action=custom_query --query="select count(*) as result from pg_tables where schemaname='analytics' and tablename like '%fact'" --warning='80' --critical='90' --valtype=integer

เรียกใช้การตรวจสอบฐานข้อมูล

คุณตรวจสอบได้ว่ามีการสร้างตารางที่ถูกต้องในฐานข้อมูล PostgreSQL หรือไม่ เข้าสู่ระบบ PostgreSQL ฐานข้อมูลโดยใช้คำสั่งต่อไปนี้

psql -h /opt/apigee/var/run/apigee-postgresql/ -U apigee -d apigee

จากนั้นเรียกใช้

\d analytics."org.env.fact"

ตรวจสอบสถานะประสิทธิภาพของกระบวนการหลังจบ

คุณตรวจสอบ API ในเครื่อง Postgres ได้โดยเรียกใช้ curl ต่อไปนี้ คำสั่ง:

curl -v http://postgres_IP:8084/v1/servers/self/health

คำสั่งนี้จะแสดงสถานะ ACTIVE เมื่อกระบวนการ Postgres ทำงานอยู่ หาก กระบวนการ Postgres ไม่ได้ทำงานและส่งคืนสถานะ INACTIVE

แหล่งข้อมูล Postgres

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการตรวจสอบบริการ Postgres โปรดดูข้อมูลต่อไปนี้

Apache Cassandra

JMX จะเปิดใช้งานโดยค่าเริ่มต้นสำหรับ Cassandra และการเข้าถึง JMX ระยะไกลไปยัง Cassandra ไม่จำเป็นต้องใช้ รหัสผ่าน

เปิดใช้การตรวจสอบสิทธิ์ JMX สำหรับ Cassandra

คุณเปิดใช้การตรวจสอบสิทธิ์ JMX สำหรับ Cassandra ได้ หลังจากนั้น คุณจะต้องดำเนินการต่อไปนี้ ส่งชื่อผู้ใช้และรหัสผ่านไปยังการเรียกใช้ยูทิลิตีของ Nodetool

วิธีเปิดใช้การตรวจสอบสิทธิ์ JMX สำหรับ Cassandra

  1. สร้างและแก้ไขไฟล์ cassandra.properties ดังนี้
    1. แก้ไขไฟล์ /opt/apigee/customer/application/cassandra.properties หาก ไม่มีไฟล์อยู่ ให้สร้างไฟล์ดังกล่าว
    2. เพิ่มข้อมูลต่อไปนี้ลงในไฟล์ 
      conf_cassandra_env_com.sun.management.jmxremote.authenticate=true
conf_cassandra_env_com.sun.management.jmxremote.password.file=${APIGEE_ROOT}/customer/application/apigee-cassandra/jmxremote.password
conf_cassandra_env_com.sun.management.jmxremote.access.file=${APIGEE_ROOT}/customer/application/apigee-cassandra/jmxremote.access
    3. บันทึกไฟล์ cassandra.properties
    4. เปลี่ยนเจ้าของไฟล์เป็น apigee:apigee ตามตัวอย่างต่อไปนี้ 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties

    ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ไฟล์พร็อพเพอร์ตี้เพื่อตั้งค่าโทเค็นได้ที่ วิธีกำหนดค่า Edge

  2. สร้างและแก้ไข jmx_auth.sh
    1. สร้างไฟล์ในตำแหน่งต่อไปนี้หากยังไม่มีไฟล์ 
      /opt/apigee/customer/application/jmx_auth.sh
    2. เพิ่มพร็อพเพอร์ตี้ต่อไปนี้ลงในไฟล์ 
      export CASS_JMX_USERNAME=JMX_USERNAME
export CASS_JMX_PASSWORD=JMX_PASSWORD
    3. บันทึกไฟล์ jmx_auth.sh
    4. แหล่งที่มาของไฟล์ 
      source /opt/apigee/customer/application/jmx_auth.sh
  3. คัดลอกและแก้ไขไฟล์ jmxremote.password โดยทำดังนี้
    1. คัดลอกไฟล์ต่อไปนี้จากไดเรกทอรี $JAVA_HOME ไปยัง /opt/apigee/customer/application/apigee-cassandra/: 
      cp ${JAVA_HOME}/lib/management/jmxremote.password.template $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password
    2. แก้ไขไฟล์ jmxremote.password และเพิ่มชื่อผู้ใช้และรหัสผ่าน JMX ของคุณ โดยใช้ไวยากรณ์ต่อไปนี้ 
      JMX_USERNAME JMX_PASSWORD

      โดยที่ JMX_USERNAME และ JMX_PASSWORD คือชื่อผู้ใช้ JMX และ ที่คุณตั้งไว้ก่อนหน้านี้

    3. ตรวจสอบว่า "apigee" เป็นเจ้าของไฟล์ และโหมดไฟล์คือ 400 
      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.password
  4. คัดลอกและแก้ไขไฟล์ jmxremote.access โดยทำดังนี้
    1. คัดลอกไฟล์ต่อไปนี้จากไดเรกทอรี $JAVA_HOME ไปยัง /opt/apigee/customer/application/apigee-cassandra/: 
      cp ${JAVA_HOME}/lib/management/jmxremote.access
$APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.access
    2. แก้ไขไฟล์ jmxremote.access และเพิ่มบทบาทต่อไปนี้ 
      JMX_USERNAME readwrite
    3. ตรวจสอบว่า "apigee" เป็นเจ้าของไฟล์ และโหมดไฟล์คือ 400 
      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
chmod 400 /opt/apigee/customer/application/apigee-cassandra/jmxremote.access
  5. เรียกใช้ configure ใน Cassandra: 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  6. รีสตาร์ท Cassandra ด้วยคำสั่งต่อไปนี้ 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  7. ทำขั้นตอนนี้ซ้ำในโหนด Cassandra อื่นๆ ทั้งหมด

เปิดใช้การเข้ารหัสรหัสผ่าน JMX

หากต้องการเปิดใช้การเข้ารหัสรหัสผ่าน JMX ให้ทำตามขั้นตอนต่อไปนี้

  1. เปิดไฟล์ source/conf/casssandra-env.sh
  2. สร้างและแก้ไขไฟล์ cassandra.properties ดังนี้
    1. แก้ไขไฟล์ /opt/apigee/customer/application/cassandra.properties ถ้า ไม่มีไฟล์อยู่ ให้สร้างไฟล์ดังกล่าว
    2. เพิ่มข้อมูลต่อไปนี้ลงในไฟล์ 
      conf_cassandra_env_com.sun.management.jmxremote.encrypted.authenticate=true
    3. บันทึกไฟล์ cassandra.properties
    4. เปลี่ยนเจ้าของไฟล์เป็น apigee:apigee ตามตัวอย่างต่อไปนี้ 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
  3. ในบรรทัดคำสั่ง ให้สร้างแฮช SHA1 ของรหัสผ่านที่ต้องการโดยป้อน echo -n 'Secret' | openssl dgst -sha1
  4. ตั้งรหัสผ่านกับชื่อผู้ใช้ใน $APIGEE_ROOT/customer/application/apigee-cassandra/jmxremote.password (สร้างใน ในส่วนก่อนหน้า)
  5. เรียกใช้การกำหนดค่าใน Cassandra 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  6. รีสตาร์ท Cassandra ด้วยคำสั่งต่อไปนี้ 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  7. ทำขั้นตอนนี้ซ้ำในโหนด Cassandra อื่นๆ ทั้งหมด

เปิดใช้ JMX พร้อม SSL สำหรับ Cassandra

การเปิดใช้ JMX กับ SSL จะช่วยเพิ่มความปลอดภัยและการเข้ารหัสสำหรับการสื่อสารที่ใช้ JMX Cassandra หากต้องการเปิดใช้งาน JMX กับ SSL คุณต้องระบุคีย์และใบรับรองแก่ Cassandra เพื่อ ยอมรับการเชื่อมต่อ JMX แบบ SSL นอกจากนี้คุณต้องกำหนดค่า Nodetool (และเครื่องมืออื่นๆ ที่ สื่อสารกับ Cassandra ผ่าน JMX) สำหรับ SSL

JMX ที่เปิดใช้ SSL รองรับทั้งรหัสผ่าน JMX แบบข้อความธรรมดาและที่เข้ารหัส

หากต้องการเปิดใช้งาน JMX ที่มี SSL สำหรับ Cassandra ให้ใช้กระบวนการต่อไปนี้

  1. เปิดใช้ JMX เปิดใช้การเข้ารหัสให้กับรหัสผ่านหากจำเป็น
  2. เปิดใช้การตรวจสอบสิทธิ์ JMX สำหรับ Cassandra ตามที่อธิบายไว้ข้างต้น ตรวจสอบว่า Nodetool ทำงานกับเครื่องมือที่กำหนดค่าไว้ ชื่อผู้ใช้และรหัสผ่าน 
    /opt/apigee/apigee-cassandra/bin/nodetool -u <JMX_USER> -pw <JMX_PASS> ring

  3. เตรียมคีย์สโตร์และ Truststore

    • คีย์สโตร์ควรมีคีย์และใบรับรอง และใช้เพื่อกำหนดค่าเซิร์ฟเวอร์ Cassandra หากคีย์สโตร์ มีคู่คีย์หลายคู่ Cassandra จะใช้คู่คีย์แรก เพื่อเปิดใช้ SSL

      โปรดทราบว่ารหัสผ่านสำหรับคีย์สโตร์และคีย์ควรเหมือนกัน (ค่าเริ่มต้นเมื่อคุณสร้างคีย์โดยใช้เครื่องมือคีย์)

    • Truststore ควรมีใบรับรองเท่านั้นและใช้โดยไคลเอ็นต์ (ตาม apigee-service คำสั่งหรือ Nodetool) เพื่อเชื่อมต่อผ่าน JMX

    หลังจากตรวจสอบข้อกำหนดข้างต้นแล้ว ให้ทำดังนี้

    1. วางไฟล์คีย์สโตร์ใน /opt/apigee/customer/application/apigee-cassandra/
    2. ตรวจสอบว่าผู้ใช้ Apigee อ่านไฟล์คีย์สโตร์ได้โดยป้อน 
      chown apigee:apigee /opt/apigee/customer/application/apigee-cassandra/keystore.node1
chmod 400 /opt/apigee/customer/application/apigee-cassandra/keystore.node1
  4. กำหนดค่า Cassandra สำหรับ JMX ที่มี SSL โดยทำตามขั้นตอนต่อไปนี้
    1. หยุดโหนด Cassandra โดยป้อน 
      apigee-service apigee-cassandra stop
    2. เปิดใช้ SSL ใน Cassandra โดย กำลังเปิดไฟล์ /opt/apigee/customer/application/cassandra.properties และเพิ่มบรรทัดต่อไปนี้ 
      conf_cassandra_env_com.sun.management.jmxremote.ssl=true
conf_cassandra_env_javax.net.ssl.keyStore=/opt/apigee/customer/application/apigee-cassandra/keystore.node1
conf_cassandra_env_javax.net.ssl.keyStorePassword=keystore-password
    3. เปลี่ยนเจ้าของไฟล์เป็น apigee:apigee ตามตัวอย่างต่อไปนี้ 
      chown apigee:apigee /opt/apigee/customer/application/cassandra.properties
    4. เรียกใช้การกำหนดค่าใน Cassandra 
      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
    5. รีสตาร์ท Cassandra ด้วยคำสั่งต่อไปนี้ 
      /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
    6. ทำขั้นตอนนี้ซ้ำในโหนด Cassandra อื่นๆ ทั้งหมด
    7. เริ่มต้นโหนด Cassandra โดยป้อน 
      apigee-service apigee-cassandra start
  5. กำหนดค่าคำสั่ง apigee-service Cassandra คุณต้องตั้งค่าตัวแปรสภาพแวดล้อมบางรายการขณะเรียกใช้ apigee-service คำสั่ง รวมถึงคำสั่งด้านล่าง 
    apigee-service apigee-cassandra stop
apigee-service apigee-cassandra wait_for_ready
apigee-service apigee-cassandra ring
apigee-service apigee-cassandra backup

    การกำหนดค่า apigee-service สำหรับการตรวจสอบสิทธิ์ JMX มีหลายตัวเลือก และ SSL เลือกตัวเลือกตามความสามารถในการใช้งานและแนวทางปฏิบัติด้านความปลอดภัยของคุณ

    ตัวเลือกที่ 1 (อาร์กิวเมนต์ SSL ที่จัดเก็บไว้ในไฟล์)

    ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้

    export CASS_JMX_USERNAME=ADMIN
# Provide encrypted password here if you have setup JMX password encryption
export CASS_JMX_PASSWORD=PASSWORD
export CASS_JMX_SSL=Y

    สร้างไฟล์ในไดเรกทอรีหน้าแรกของผู้ใช้ Apigee (/opt/apigee) 

    $HOME/.cassandra/nodetool-ssl.properties

    แก้ไขไฟล์และเพิ่มบรรทัดต่อไปนี้

    -Djavax.net.ssl.trustStore=<path-to-truststore.node1>
-Djavax.net.ssl.trustStorePassword=<truststore-password>
-Dcom.sun.management.jmxremote.registry.ssl=true

    ตรวจสอบว่าผู้ใช้ Apigee สามารถอ่านไฟล์ Trustore ได้

    เรียกใช้คำสั่ง apigee-service ต่อไปนี้ หากทำงานโดยไม่มีข้อผิดพลาด แสดงว่าการกำหนดค่าถูกต้อง

    apigee-service apigee-cassandra ring

    ตัวเลือกที่ 2 (อาร์กิวเมนต์ SSL ที่จัดเก็บไว้ในตัวแปรสภาพแวดล้อม)

    ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้

    export CASS_JMX_USERNAME=ADMIN
# Provide encrypted password here if you have setup JMX password encryption
export CASS_JMX_PASSWORD=PASSWORD
export CASS_JMX_SSL=Y
# Ensure the truststore file is accessible by Apigee user.
export CASS_JMX_TRUSTSTORE=<path-to-trustore.node1>
export CASS_JMX_TRUSTSTORE_PASSWORD=<truststore-password>

    เรียกใช้คำสั่ง apigee-service ต่อไปนี้ หากทำงานโดยไม่มีข้อผิดพลาด แสดงว่าการกำหนดค่าถูกต้อง 

    apigee-service apigee-cassandra ring

    ตัวเลือกที่ 3 (อาร์กิวเมนต์ SSL ที่ส่งผ่านไปยัง apigee-service โดยตรง)

    เรียกใช้คำสั่ง apigee-service เหมือนกับคำสั่งด้านล่าง โดยไม่จำเป็นต้องกำหนดค่าตัวแปรสภาพแวดล้อม

    CASS_JMX_USERNAME=ADMIN CASS_JMX_PASSWORD=PASSWORD CASS_JMX_SSL=Y CASS_JMX_TRUSTSTORE=<path-to-trustore.node1> CASS_JMX_TRUSTSTORE_PASSWORD=<trustore-password> /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra ring

  6. ตั้งค่า Nodetool Nodetool กำหนดให้ส่งพารามิเตอร์ JMX ไปยังเครื่องมือดังกล่าว ซึ่งมี 2 วิธี คุณสามารถกำหนดค่า Nodetool ให้ทำงานด้วย JMX ที่เปิดใช้ SSL ตามที่ได้อธิบายไว้ใน ตัวเลือกการกำหนดค่าด้านล่าง

    ตัวเลือกนี้มีความแตกต่างที่วิธีส่งการกำหนดค่าที่เกี่ยวข้องกับ SSL ไปยัง Nodetool ในทั้ง 2 กรณี ผู้ใช้ที่เรียกใช้ Nodetool ควรมีสิทธิ์การอ่านในไฟล์ Truststore เลือกตัวเลือกที่เหมาะสมตามความสามารถในการใช้งานและแนวทางปฏิบัติด้านความปลอดภัยของคุณ

    หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับพารามิเตอร์ Nodetool โปรดดู เอกสารประกอบ DataStax

    ตัวเลือกการกำหนดค่า 1

    สร้างไฟล์ในไดเรกทอรีหน้าแรกของผู้ใช้ที่เรียกใช้ Nodetool

    $HOME/.cassandra/nodetool-ssl.properties

    เพิ่มบรรทัดต่อไปนี้ลงในไฟล์

    -Djavax.net.ssl.trustStore=<path-to-truststore.node1>
-Djavax.net.ssl.trustStorePassword=<truststore-password>
-Dcom.sun.management.jmxremote.registry.ssl=true

    เส้นทาง Truststore ที่ระบุข้างต้นควรเข้าถึงได้โดยผู้ใช้ทุกคนที่กำลังใช้งาน nodetool.

    เรียกใช้ nodetool ด้วยตัวเลือก --ssl

    /opt/apigee/apigee-cassandra/bin/nodetool --ssl -u <jmx-user-name> -pw <jmx-user-password> -h localhost ring

    ตัวเลือกการกำหนดค่า 2

    เรียกใช้ nodetool เป็นคำสั่งเดียวโดยมีพารามิเตอร์เพิ่มเติมตามรายการด้านล่าง

    /opt/apigee/apigee-cassandra/bin/nodetool -Djavax.net.ssl.trustStore=<path-to-truststore.node1> -Djavax.net.ssl.trustStorePassword=<truststore-password> -Dcom.sun.management.jmxremote.registry.ssl=true -Dssl.enable=true -u <jmx-user-name> -pw <jmx-user-password> -h localhost ring

เปลี่ยนกลับการกำหนดค่า SSL

ถ้าคุณต้องการเปลี่ยนกลับการกำหนดค่า SSL ที่อธิบายไว้ในขั้นตอนนี้ ด้านบน โปรดทำตามขั้นตอนต่อไปนี้

  1. หยุดapigee-cassandraด้วยการเข้า 
    apigee-service apigee-cassandra stop
  2. นำบรรทัด conf_cassandra-env_com.sun.management.jmxremote.ssl=true ออกจาก ไฟล์ /opt/apigee/customer/application/cassandra.properties
  3. แสดงความคิดเห็นบรรทัดต่อไปนี้ใน /opt/apigee/apigee-cassandra/source/conf/cassandra-env.sh 
    # JVM_OPTS="$JVM_OPTS -Djavax.net.ssl.keyStore=/opt/apigee/data/apigee-cassandra/keystore.node0"
# JVM_OPTS="$JVM_OPTS -Djavax.net.ssl.keyStorePassword=keypass"
# JVM_OPTS="$JVM_OPTS -Dcom.sun.management.jmxremote.registry.ssl=true”
  4. เริ่ม apigee-cassandra ด้วยการเข้า
    5. apigee-service apigee-cassandra start
  5. นําตัวแปรสภาพแวดล้อม CASS_JMX_SSL ออก หากตั้งค่าไว้

    unset CASS_JMX_SSL
  6. ตรวจสอบว่าคำสั่งที่อิงตาม apigee-service เช่น ring, stop, backup และอื่นๆ กำลังทำงาน
  7. หยุดใช้สวิตช์ --ssl กับ Nodetool

ปิดใช้การตรวจสอบสิทธิ์ JMX สำหรับ Cassandra

วิธีปิดใช้การตรวจสอบสิทธิ์ JMX สำหรับ Cassandra

  1. แก้ไข /opt/apigee/customer/application/cassandra.properties
  2. นำบรรทัดต่อไปนี้ในไฟล์ออก 
    conf_cassandra-env_com.sun.management.jmxremote.authenticate=true
  3. เรียกใช้การกำหนดค่าใน Cassandra 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra configure
  4. รีสตาร์ท Cassandra ด้วยคำสั่งต่อไปนี้ 
    /opt/apigee/apigee-service/bin/apigee-service apigee-cassandra restart
  5. ทำขั้นตอนนี้ซ้ำในโหนด Cassandra อื่นๆ ทั้งหมด

ใช้ JConsole: ตรวจสอบสถิติของงาน

ใช้ JConsole และ URL บริการต่อไปนี้เพื่อตรวจสอบแอตทริบิวต์ JMX (MBeans) ที่ให้บริการผ่าน JMX:

service:jmx:rmi:///jndi/rmi://IP_address:7199/jmxrmi

โดยที่ IP_address คือ IP ของเซิร์ฟเวอร์ Cassandra

สถิติของ Cassandra JMX

JMX MBeans แอตทริบิวต์ของ JMX

ColumnFamilies/apprepo/environments

ColumnFamilies/apprepo/organizations

ColumnFamilies/apprepo/apiproxy_revisions

ColumnFamilies/apprepo/apiproxies

ColumnFamilies/audit/audits

ColumnFamilies/audit/audits_ref

PendingTasks

MemtableColumnsCount

MemtableDataSize

ReadCount

RecentReadLatencyMicros

TotalReadLatencyMicros

WriteCount

RecentWriteLatencyMicros

TotalWriteLatencyMicros

TotalDiskSpaceUsed

LiveDiskSpaceUsed

LiveSSTableCount

BloomFilterFalsePositives

RecentBloomFilterFalseRatio

BloomFilterFalseRatio

ใช้ Nodetool เพื่อจัดการโหนดของคลัสเตอร์

ยูทิลิตี Nodetool คืออินเทอร์เฟซบรรทัดคำสั่งสำหรับ Cassandra ที่จัดการ โหนดคลัสเตอร์ คุณสามารถรับยูทิลิตีได้ที่ /opt/apigee/apigee-cassandra/bin

การเรียกต่อไปนี้สามารถทำบนโหนดคลัสเตอร์ Cassandra ทั้งหมดได้

  1. ข้อมูลทั่วไปของเสียงเรียกเข้า (สำหรับโหนด Cassandra เดี่ยว): มองหา "ขึ้น" และ "ปกติ" สำหรับโหนดทั้งหมด 
    nodetool [-u username -pw password] -h localhost ring

    คุณต้องส่งชื่อผู้ใช้และรหัสผ่านเฉพาะในกรณีต่อไปนี้ เปิดใช้การตรวจสอบสิทธิ์ JMX สำหรับ Cassandra

    เอาต์พุตของคำสั่งข้างต้นมีลักษณะดังต่อไปนี้ 

    Datacenter: dc-1
==========
Address            Rack     Status State   Load    Owns    Token
192.168.124.201    ra1      Up     Normal  1.67 MB 33,33%  0
192.168.124.202    ra1      Up     Normal  1.68 MB 33,33%  5671...5242
192.168.124.203    ra1      Up     Normal  1.67 MB 33,33%  1134...0484
  2. ข้อมูลทั่วไปเกี่ยวกับโหนด (การเรียกใช้ต่อโหนด) 
    nodetool [-u username -pw password]  -h localhost info

    เอาต์พุตของคำสั่งด้านบนจะมีลักษณะดังต่อไปนี้

    ID                     : e2e42793-4242-4e82-bcf0-oicu812
Gossip active          : true
Thrift active          : true
Native Transport active: true
Load                   : 273.71 KB
Generation No          : 1234567890
Uptime (seconds)       : 687194
Heap Memory (MB)       : 314.62 / 3680.00
Off Heap Memory (MB)   : 0.14
Data Center            : dc-1
Rack                   : ra-1
Exceptions             : 0
Key Cache              : entries 150, size 13.52 KB, capacity 100 MB, 1520781 hits, 1520923 requests, 1.000 recent hit rate, 14400 save period in seconds
Row Cache              : entries 0, size 0 bytes, capacity 0 bytes, 0 hits, 0 requests, NaN recent hit rate, 0 save period in seconds
Counter Cache          : entries 0, size 0 bytes, capacity 50 MB, 0 hits, 0 requests, NaN recent hit rate, 7200 save period in seconds
Token                  : 0
  3. สถานะเซิร์ฟเวอร์สำเร็จรูป (แสดงไคลเอ็นต์ API) 
    nodetool [-u username -pw password] -h localhost statusthrift

    เอาต์พุตของคำสั่งด้านบนจะมีลักษณะดังต่อไปนี้

    running
  4. สถานะของการดำเนินการสตรีมมิงข้อมูล: สังเกตการรับส่งข้อมูลของโหนด Cassandra ดังนี้ 
    nodetool [-u username -pw password] -h localhost netstats

    เอาต์พุตของคำสั่งด้านบนจะมีลักษณะดังต่อไปนี้

    Mode: NORMAL
Not sending any streams.
Read Repair Statistics:
Attempted: 151612
Mismatch (Blocking): 0
Mismatch (Background): 0
Pool Name                    Active   Pending      Completed   Dropped
Commands                        n/a         0              0         0
Responses                       n/a         0              0       n/a

ดูข้อมูลเพิ่มเติมเกี่ยวกับ Nodetool ได้ที่ เกี่ยวกับยูทิลิตี Nodetool

แหล่งข้อมูล Cassandra

โปรดดู URL ต่อไปนี้ http://www.datastax.com/docs/1.0/operations/monitoring

การตรวจสอบ Apache Qpid Broker-J

คุณสามารถตรวจสอบ Qpid Broker-J ได้จากคอนโซลการจัดการ Qpid ส่วนนี้อธิบายถึง วิธีเข้าถึงคอนโซลและใช้เพื่อใช้ฟังก์ชันการตรวจสอบขั้นพื้นฐาน หากต้องการทราบรายละเอียดเพิ่มเติม เกี่ยวกับการใช้คอนโซลการจัดการ โปรดดู Web Management Console ในเอกสารประกอบของ Apache Qpid

เข้าถึงคอนโซลการจัดการ

พอร์ตคอนโซลการจัดการเริ่มต้นคือ 8090 วิธีเข้าถึงคอนโซลบนพอร์ตเริ่มต้นนี้ กำหนดให้เว็บเบราว์เซอร์ไปที่:

http://QPID_NODE_IP:8090

หากต้องการเข้าสู่ระบบคอนโซล ให้ใช้ข้อมูลเข้าสู่ระบบเริ่มต้นที่ Apigee กำหนดหรือข้อมูลที่ตั้งค่าใน ไฟล์การกำหนดค่า Edge โปรดดูรายละเอียดที่หัวข้อ ข้อมูลอ้างอิงไฟล์การกำหนดค่า Edge

ตรวจสอบคิวและข้อความ

ในแผงการนำทางด้านซ้าย ให้ไปที่ Java-Broker > โฮสต์เสมือน > คิว เลือก เพื่อดูรายละเอียดในส่วนหลักของ UI ในมุมมองรายละเอียด คุณจะเห็น แอตทริบิวต์และสถิติในคิว รวมถึงข้อมูลเกี่ยวกับข้อความที่ส่ง ที่จัดคิว อัตราข้อความ และอื่นๆ

ดูและดาวน์โหลดไฟล์บันทึก

ในแผงการนำทางด้านซ้าย ให้ไปที่ Java-Broker > โบรกเกอร์ > logfile ใน มุมมองรายละเอียด UI หลัก คุณจะดูรายละเอียดไฟล์บันทึกและดาวน์โหลดไฟล์บันทึกได้

การใช้ Qpid Management API

คุณสามารถใช้ Apache Qpid Broker-J REST API เพื่อจัดการงานจัดการและตรวจสอบนายหน้าโดยอัตโนมัติ โปรดดูรายละเอียดที่ เอกสาร REST API ของ Apache Qpid Broker

นอกจากนี้คุณยังใช้เครื่องมือบรรทัดคำสั่งเพื่อตรวจสอบนายหน้าได้ด้วย เช่น

curl "QPID_NODE_IP":"8090"/api/latest/broker -u "USERNAME":"PASSWORD"

Apache ZooKeeper

ตรวจสอบสถานะ ZooKeeper

  1. ตรวจสอบว่ากระบวนการ ZooKeeper กำลังทำงานอยู่ ZooKeeper เขียนไฟล์ PID ไปยัง opt/apigee/var/run/apigee-zookeeper/apigee-zookeeper.pid
  2. ทดสอบพอร์ต ZooKeeper เพื่อให้แน่ใจว่าคุณสามารถสร้างการเชื่อมต่อ TCP ไปยังพอร์ต 2181 และ 3888 บนเซิร์ฟเวอร์ ZooKeeper ทั้งหมด
  3. ตรวจสอบว่าคุณอ่านค่าจากฐานข้อมูล ZooKeeper ได้ เชื่อมต่อโดยใช้ ZooKeeper ไลบรารีของไคลเอ็นต์ (หรือ /opt/apigee/apigee-zookeeper/bin/zkCli.sh) และอ่านค่า จากฐานข้อมูล
  4. ตรวจสอบสถานะดังนี้ 
    /opt/apigee/apigee-service/bin/apigee-service apigee-zookeeper status

ใช้คำที่มีตัวอักษร 4 ตัวของ ZooKeeper

สามารถตรวจสอบ ZooKeeper ผ่านชุดคำสั่งสั้นๆ (ตัวอักษร 4 ตัว) ที่ส่งไปยัง พอร์ต 2181 โดยใช้ netcat (nc) หรือ telnet

โปรดดูข้อมูลเพิ่มเติมเกี่ยวกับคำสั่ง ZooKeeper ที่หัวข้อการอ้างอิงคำสั่ง ZooKeeper

เช่น

  • srvr: แสดงรายละเอียดทั้งหมดสำหรับเซิร์ฟเวอร์
  • stat: แสดงรายละเอียดสั้นๆ สำหรับเซิร์ฟเวอร์และไคลเอ็นต์ที่เชื่อมต่อ

คำสั่งต่อไปนี้ออกไปยังพอร์ต ZooKeeper ได้

  1. เรียกใช้ ruok ของคำสั่งแบบ 4 ตัวอักษรเพื่อทดสอบว่าเซิร์ฟเวอร์ทำงานอยู่ในสถานะที่ไม่ใช่ข้อผิดพลาดหรือไม่ ต การตอบกลับที่สำเร็จจะแสดง "imok" 
    echo ruok | nc host 2181

    ค่าที่ส่งคืน:

    imok
  2. เรียกใช้คำสั่ง 4 ตัวอักษร stat เพื่อแสดงประสิทธิภาพของเซิร์ฟเวอร์และเชื่อมต่อแล้ว สถิติลูกค้า: 
    echo stat | nc host 2181

    ค่าที่ส่งคืน:

    Zookeeper version: 3.4.5-1392090, built on 09/30/2012 17:52 GMT
Clients:
/0:0:0:0:0:0:0:1:33467[0](queued=0,recved=1,sent=0)
/192.168.124.201:42388[1](queued=0,recved=8433,sent=8433)
/192.168.124.202:42185[1](queued=0,recved=1339,sent=1347)
/192.168.124.204:39296[1](queued=0,recved=7688,sent=7692)
Latency min/avg/max: 0/0/128
Received: 26144
Sent: 26160
Connections: 4
Outstanding: 0
Zxid: 0x2000002c2
Mode: follower
Node count: 283
  3. หาก netcat (nc) ไม่พร้อมใช้งาน คุณสามารถใช้ Python แทนได้ สร้างไฟล์ ชื่อ zookeeper.py ที่มีสิ่งต่อไปนี้ 
    import time, socket,
sys c = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
c.connect((sys.argv[1], 2181))
c.send(sys.argv[2])
time.sleep(0.1)
print c.recv(512)

    เรียกใช้บรรทัด Python ต่อไปนี้

    python zookeeper.py 192.168.124.201 ruok
python zookeeper.py 192.168.124.201 stat

การทดสอบระดับ LDAP

คุณตรวจสอบ OpenLDAP ได้เพื่อดูว่าคำขอที่ระบุแสดงอย่างถูกต้องหรือไม่ ใน เช่น ตรวจหาการค้นหาเฉพาะที่แสดงผลการค้นหาที่ถูกต้อง

  1. ใช้ ldapsearch (yum install openldap-clients) เพื่อค้นหาข้อมูล ของผู้ดูแลระบบ รายการนี้ใช้เพื่อตรวจสอบสิทธิ์การเรียก API ทั้งหมด 
    ldapsearch -b "uid=admin,ou=users,ou=global,dc=apigee,dc=com" -x -W -D "cn=manager,dc=apigee,dc=com" -H ldap://localhost:10389 -LLL

    จากนั้นระบบจะแจ้งให้คุณใส่รหัสผ่านของผู้ดูแลระบบ LDAP ดังนี้

    Enter LDAP Password:

    หลังจากป้อนรหัสผ่าน คุณจะเห็นการตอบกลับในแบบฟอร์ม

    dn:
uid=admin,ou=users,ou=global,dc=apigee,dc=com
objectClass: organizationalPerson
objectClass: person
objectClass: inetOrgPerson
objectClass: top
uid: admin
cn: admin
sn: admin
userPassword:: e1NTSEF9bS9xbS9RbVNXSFFtUWVsU1F0c3BGL3BQMkhObFp2eDFKUytmZVE9PQ=
 =
mail: opdk@google.com
  2. ตรวจสอบว่าเซิร์ฟเวอร์การจัดการยังเชื่อมต่อกับ LDAP ด้วยคำสั่งต่อไปนี้หรือไม่ 
    curl -u userEMail:password http://localhost:8080/v1/users/ADMIN

    ค่าที่ส่งคืน:

    {
  "emailId" : ADMIN,
  "firstName" : "admin",
  "lastName" : "admin"
}

นอกจากนี้ คุณยังสามารถตรวจสอบแคชของ OpenLDAP ได้ ซึ่งจะช่วยลดจำนวนการเข้าถึงดิสก์ และปรับปรุงประสิทธิภาพของระบบ การตรวจสอบแล้วปรับขนาดของแคชใน เซิร์ฟเวอร์ OpenLDAP อาจส่งผลกระทบอย่างมากต่อประสิทธิภาพการทำงานของเซิร์ฟเวอร์ไดเรกทอรี คุณสามารถดูบันทึก (opt/apigee/var/log) เพื่อรับข้อมูลเกี่ยวกับแคช