google cloud java

ไลบรารีไคลเอ็นต์ Google Cloud Java

ไคลเอนต์สำนวน Java สำหรับบริการ Google Cloud Platform

• ชวาบน Google Cloud

API ที่รองรับ

ไลบรารีพร้อมใช้งานบน GitHub และ Maven Central สำหรับการพัฒนาแอปพลิเคชัน Java ที่โต้ตอบกับบริการ Google Cloud แต่ละรายการ:

ลูกค้า	ระดับการเปิดตัว	เวอร์ชัน
สมุดบันทึกแพลตฟอร์ม AI
เกตเวย์ API
API คีย์ API
การอนุมัติการเข้าถึง
API การแจ้งเตือนคำแนะนำ
ล้อแม็กDB
ตัวเชื่อมต่อ AlloyDB
API ฮับการวิเคราะห์
Apigee เชื่อมต่อ
API ผู้ดูแลระบบ App Engine
ทะเบียนสิ่งประดิษฐ์
สินค้าคงคลังสินทรัพย์
รับประกันภาระงานสำหรับภาครัฐ
ออโต้เอ็มแอล
API การสำรองข้อมูลและ DR Service
BigQuery
การเชื่อมต่อ BigQuery
บริการโอนข้อมูล BigQuery
การจอง BigQuery
พื้นที่เก็บข้อมูล BigQuery
บิ๊กเทเบิ้ล
ลูกค้า Bigtable Hbase
การเรียกเก็บเงิน
งบประมาณการเรียกเก็บเงิน
การอนุญาตแบบไบนารี
สร้าง
ข้อมูลเชิงลึกของ CCAI
บริการผู้ออกใบรับรอง
บริการช่องทาง
ผู้แต่ง
เครื่องยนต์คำนวณ
เชื่อมต่อเกตเวย์ API
การวิเคราะห์คอนเทนเนอร์
ควบคุม API ของพันธมิตร
DNS
แค็ตตาล็อกข้อมูล
การรวมข้อมูล
สายข้อมูล
การป้องกันข้อมูลสูญหาย
บริการย้ายฐานข้อมูล
ดาต้าเพล็กซ์
Dataproc
Dataproc Metastore
พื้นที่เก็บข้อมูล
ดาต้าสตรีม
ดีบักเกอร์
ปรับใช้
API ไดอะล็อกโฟลว์
API การค้นพบเครื่องยนต์
ขอบแบบกระจาย
API เครือข่าย Edge แบบกระจาย
เอกสารเอไอ
โดเมน
API ผู้ติดต่อที่จำเป็น
อีเวนทาร์ค
API ของที่เก็บไฟล์
ร้านดับเพลิง
เส้นทางเดินเรือ
ฟังก์ชั่น
API ฮับ GKE
ฉัน
API ผู้ดูแลระบบ IAM
API ตัวแก้ไขปัญหานโยบาย IAM
API ข้อมูลรับรองบัญชีบริการ IAM
ตัวจัดการบริบทการเข้าถึงข้อมูลประจำตัว
Identity-Aware Proxy API
API ผู้จัดการโครงสร้างพื้นฐาน
อินเทอร์เน็ตของสรรพสิ่ง (IoT) แกนหลัก
ระบบตรวจจับการบุกรุก
บริการการจัดการคีย์
เครื่องยนต์ Kubernetes
การบันทึก
บริการที่ได้รับการจัดการสำหรับ Microsoft Active Directory
เมมแคช
การตรวจสอบแดชบอร์ด
ภาษาธรรมชาติ
ศูนย์การเชื่อมต่อเครือข่าย
API การจัดการเครือข่าย
API ความปลอดภัยของเครือข่าย
API การกำหนดค่าระบบปฏิบัติการ
เข้าสู่ระบบระบบปฏิบัติการ
นโยบายองค์กร
ผู้สร้างโปรไฟล์
ผับ/ซับ
Pub/Sub Group Kafka Connector
ผับ/ซับไลท์
ผับ/ซับ ไลท์ คาฟคา ชิม
ตัวเชื่อมต่อ Spark Pub/Sub Lite
API ผู้ออกใบรับรองสาธารณะ
API โควต้า
ผู้แนะนำ
เรดิส
API ตัวจัดการทรัพยากร
API การตั้งค่าทรัพยากร
ขายปลีก
API เส้นทาง
กำหนดการ
การจัดการความลับ
API ตัวจัดการแหล่งที่มาที่ปลอดภัย
API การจัดการศูนย์ความปลอดภัย
ศูนย์บัญชาการรักษาความปลอดภัย
API ท่าทางการรักษาความปลอดภัย
เครื่องสแกนความปลอดภัย
การเข้าถึง VPC แบบไร้เซิร์ฟเวอร์
API การควบคุมบริการ
ไดเรกทอรีบริการ
API การจัดการบริการ
การใช้บริการ
เปลือก
ประแจ
ประแจ JDBC
คำพูด
การตรวจสอบ Stackdriver
การติดตาม Stackdriver
พื้นที่จัดเก็บ
บริการถ่ายโอนการจัดเก็บ
ทีพียู
โซลูชั่นความสามารถพิเศษ
งาน
API อัตโนมัติของ Telco
ข้อความเป็นคำพูด
การแปล
การโยกย้าย VM
เวอร์เท็กซ์ เอไอ
Vertex AI API
วิดีโออัจฉริยะ
API เครื่องมือตัดต่อวิดีโอ
ตัวแปลงรหัสวิดีโอ
วิสัยทัศน์
ความเสี่ยงทางเว็บ
การดำเนินการเวิร์กโฟลว์
ขั้นตอนการทำงาน
API ส่วนเสริมของ Workspace
เวิร์กสเตชัน
reCAPTCHA องค์กร
API ฮับ API
API ของตัวจัดการโฆษณา
API การตรวจสอบที่อยู่
ผู้ดูแลระบบการวิเคราะห์
ข้อมูลการวิเคราะห์
ศูนย์กลางการวิเคราะห์
Anthos มัลติคลาวด์
บริการที่ได้รับการจัดการสำหรับ Apache Kafka API
API ฮับแอป
พื้นที่ 120 โต๊ะ
การสำรองข้อมูลสำหรับ GKE
โซลูชันโลหะเปลือย
แบทช์
การเชื่อมต่อแอป BeyondCorp
BeyondCorp AppConnectors
แอพ BeyondCorp เกตเวย์
BeyondCorp ClientConnectorServices
BeyondCorp ลูกค้าเกตเวย์
บิ๊กเลค
API นโยบายข้อมูล BigQuery
การโยกย้าย BigQuery
ซีเอสเอพีไอ
ผู้จัดการใบรับรอง
API แชท
การจัดซื้อจัดจ้างผู้บริโภคเชิงพาณิชย์
API คอมพิวเตอร์ที่เป็นความลับ
เชื่อมต่อเกตเวย์ API
การติดฉลากข้อมูล
กระแสข้อมูล
ดาต้าฟอร์ม
API การเชื่อมต่อสำหรับนักพัฒนา
ไดอะล็อกโฟลว์ CX
เอกสาร AI คลังสินค้า
กราฟความรู้ระดับองค์กร
การรายงานข้อผิดพลาด
สำนักพิมพ์ Eventarc
API การจัดการฮาร์ดแวร์ GDC
API สินค้าคงคลัง KMS
วิทยาศาสตร์ชีวภาพ
API สตรีมสด
การบันทึก Logback Appender
การบันทึก Servlet Initializer
API ชุดข้อมูลแพลตฟอร์มแผนที่
API ผู้ดูแลระบบแพลตฟอร์มการตลาด
API การแปลสื่อ
พบกับ API
ที่เก็บหน่วยความจำสำหรับ Redis API
API ของผู้ขาย
API ของผู้ขาย
API ของผู้ขาย
API ของผู้ขาย
API ของผู้ขาย
API ของผู้ขาย
API การแปลงผู้ขาย
API ของผู้ขาย LFP
API การแจ้งเตือนผู้ขาย
API โควต้าผู้ขาย
API ศูนย์การย้ายข้อมูล
การตรวจสอบขอบเขตการวัด
ผู้ให้บริการระบบไฟล์ NIO สำหรับการจัดเก็บข้อมูล
เน็ตแอพ API
API บริการเครือข่าย
ออราเคิลฐานข้อมูล@API
API ของร้านค้าคู่ขนาน
การป้องกันฟิชชิ่ง
API สถานที่ (ใหม่)
API ข้อมูลเชิงลึกของสถานที่
API ตัวจำลองนโยบาย
แคตตาล็อกส่วนตัว
API ตัวจัดการการเข้าถึงที่มีสิทธิพิเศษ
ตัวเชื่อมต่อ Flink Pub/Sub Lite
API การประเมินการย้ายข้อมูลอย่างรวดเร็ว
คำแนะนำเอไอ
API รีจิสทรี
API การเพิ่มประสิทธิภาพเส้นทาง
วิ่ง
API การตั้งค่าศูนย์บัญชาการรักษาความปลอดภัย
API ความสมบูรณ์ของบริการ
พลังงานแสงอาทิตย์ API
API ข้อมูลเชิงลึกของพื้นที่เก็บข้อมูล
รองรับเอพีไอ
เครื่องยนต์วีเอ็มแวร์
วิสัยทัศน์ AI API
API กิจกรรมของพื้นที่ทำงาน

หากไม่มีบริการอยู่ในรายการ อินเทอร์เฟซ google-api-java-client พร้อมด้วย Google Cloud API เพิ่มเติมโดยใช้อินเทอร์เฟซ REST เดิม

เมื่อสร้างแอปพลิเคชัน Java ควรกำหนดการตั้งค่าให้กับไลบรารีที่แสดงอยู่ในตาราง

การระบุรหัสโครงการ

ไลบรารี google-cloud ส่วนใหญ่ต้องมีรหัสโปรเจ็กต์ มีหลายวิธีในการระบุรหัสโปรเจ็กต์นี้

1. เมื่อใช้ไลบรารี google-cloud จากภายใน Compute/App Engine ไม่จำเป็นต้องระบุรหัสโปรเจ็กต์ มันถูกอนุมานโดยอัตโนมัติจากสภาพแวดล้อมการใช้งานจริง
2. เมื่อใช้ google-cloud ที่อื่น คุณสามารถดำเนินการอย่างใดอย่างหนึ่งต่อไปนี้:

• ระบุรหัสโปรเจ็กต์เมื่อสร้างตัวเลือกบริการ ตัวอย่างเช่น หากต้องการใช้ Datastore จากโปรเจ็กต์ที่มี ID "PROJECT_ID" คุณสามารถเขียน:

   Datastore datastore = DatastoreOptions . newBuilder (). setProjectId ( "PROJECT_ID" ). build (). getService ();

• ระบุตัวแปรสภาพแวดล้อม GOOGLE_CLOUD_PROJECT ให้เป็นรหัสโปรเจ็กต์ที่คุณต้องการ

• ตั้งค่ารหัสโปรเจ็กต์โดยใช้ Google Cloud SDK หากต้องการใช้ SDK ให้ดาวน์โหลด SDK หากยังไม่ได้ดาวน์โหลด และตั้งค่ารหัสโปรเจ็กต์จากบรรทัดคำสั่ง ตัวอย่างเช่น:

   gcloud config set project PROJECT_ID
  

google-cloud กำหนดรหัสโปรเจ็กต์จากแหล่งที่มาต่อไปนี้ตามลำดับที่แสดง และหยุดเมื่อพบค่า:

1. รหัสโปรเจ็กต์ที่ให้มาเมื่อสร้างตัวเลือกบริการ
2. รหัสโครงการที่ระบุโดยตัวแปรสภาพแวดล้อม GOOGLE_CLOUD_PROJECT
3. รหัสโปรเจ็กต์ App Engine / Compute Engine
4. รหัสโปรเจ็กต์ที่ระบุในไฟล์ข้อมูลรับรอง JSON ที่ชี้โดยตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS
5. รหัสโครงการ Google Cloud SDK

ในกรณีที่ห้องสมุดอาจคาดหวังรหัสโปรเจ็กต์อย่างชัดเจน เราจะจัดเตรียมตัวช่วยที่สามารถให้รหัสโปรเจ็กต์ที่อนุมานได้:

  import com . google . cloud . ServiceOptions ;
  ...
  String projectId = ServiceOptions . getDefaultProjectId ();

การรับรองความถูกต้อง

google-cloud-java ใช้ https://github.com/googleapis/google-auth-library-java เพื่อตรวจสอบสิทธิ์คำขอ google-auth-library-java รองรับประเภทการตรวจสอบความถูกต้องที่หลากหลาย ดู README และ javadoc ของโครงการสำหรับรายละเอียดเพิ่มเติม

สภาพแวดล้อมแพลตฟอร์ม Google Cloud

เมื่อใช้ไลบรารี Google Cloud จากสภาพแวดล้อม Google Cloud Platform เช่น Compute Engine, Kubernetes Engine หรือ App Engine ไม่จำเป็นต้องมีขั้นตอนการตรวจสอบสิทธิ์เพิ่มเติม

ตัวอย่างเช่น:

 Storage storage = StorageOptions . getDefaultInstance (). getService ();

หรือ:

 CloudTasksClient cloudTasksClient = CloudTasksClient . create ();

สภาพแวดล้อมอื่นๆ

การใช้บัญชีบริการ (แนะนำ)

1. สร้างคีย์บัญชีบริการ JSON

2. หลังจากดาวน์โหลดคีย์นั้นแล้ว คุณต้องดำเนินการอย่างใดอย่างหนึ่งต่อไปนี้:

   • กำหนดตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS ให้เป็นตำแหน่งของคีย์ ตัวอย่างเช่น:

    export GOOGLE_APPLICATION_CREDENTIALS=/path/to/my/key.json

   • ระบุไฟล์ข้อมูลรับรอง JSON เมื่อสร้างตัวเลือกบริการ ตัวอย่างเช่น ออบเจ็กต์ Storage นี้มีสิทธิ์ที่จำเป็นในการโต้ตอบกับข้อมูล Google Cloud Storage ของคุณ:

    Storage storage = StorageOptions . newBuilder ()
       . setCredentials ( ServiceAccountCredentials . fromStream ( new FileInputStream ( "/path/to/my/key.json" )))
       . build ()
       . getService ();

การพัฒนา/การทดสอบในท้องถิ่น

หากทำงานในพื้นที่เพื่อการพัฒนา/การทดสอบ คุณสามารถใช้ Google Cloud SDK ได้ สร้างข้อมูลรับรองเริ่มต้นของแอปพลิเคชันด้วย gcloud auth application-default login จากนั้น google-cloud จะตรวจจับข้อมูลรับรองดังกล่าวโดยอัตโนมัติ

โทเค็นการเข้าถึง OAuth2 ที่มีอยู่

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

 Credentials credentials = GoogleCredentials . create ( new AccessToken ( accessToken , expirationTime ));
Storage storage = StorageOptions . newBuilder ()
    . setCredentials ( credentials )
    . build ()
    . getService ();

หรือ:

 Credentials credentials = GoogleCredentials . create ( new AccessToken ( accessToken , expirationTime ));
CloudTasksSettings cloudTasksSettings = CloudTasksSettings . newBuilder ()
    . setCredentialProvider ( FixedCredentialsProvider . create ( credentials ))
    . build ();
CloudTasksClient cloudTasksClient = CloudTasksClient . create ( cloudTasksSettings );

ข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน

หากไม่มีการระบุข้อมูลรับรอง google-cloud จะพยายามตรวจจับจากสภาพแวดล้อมโดยใช้ GoogleCredentials.getApplicationDefault() ซึ่งจะค้นหาข้อมูลรับรองเริ่มต้นของแอปพลิเคชันในตำแหน่งต่อไปนี้ (ตามลำดับ):

1. ไฟล์ข้อมูลรับรองที่ตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS ชี้ไป
2. ข้อมูลรับรองที่ได้รับจากคำสั่ง gcloud auth application-default login
3. ข้อมูลรับรองในตัวของ Google App Engine
4. ข้อมูลรับรองในตัวของ Google Cloud Shell
5. ข้อมูลรับรองในตัวของ Google Compute Engine

การตรวจสอบสิทธิ์ด้วยคีย์ API

การตรวจสอบสิทธิ์ด้วยคีย์ API ได้รับการสนับสนุนโดย Google Cloud API จำนวนหนึ่ง

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

ตัวอย่างเช่น หากต้องการตั้งค่าคีย์ API ด้วยบริการภาษา:

 public LanguageServiceClient createGrpcClientWithApiKey ( String apiKey ) throws Exception {
    // Manually set the api key via the header
    Map < String , String > header = new HashMap < String , String >() { { put ( "x-goog-api-key" , apiKey );}};
    FixedHeaderProvider headerProvider = FixedHeaderProvider . create ( header );

    // Create the client
    TransportChannelProvider transportChannelProvider = InstantiatingGrpcChannelProvider . newBuilder (). setHeaderProvider ( headerProvider ). build ();
    LanguageServiceSettings settings = LanguageServiceSettings . newBuilder (). setTransportChannelProvider ( transportChannelProvider ). build ();
    LanguageServiceClient client = LanguageServiceClient . create ( settings );
    return client ;
  }

ตัวอย่างการสร้างอินสแตนซ์ด้วย Language Client โดยใช้ส่วนที่เหลือ:

 public LanguageServiceClient createRestClientWithApiKey ( String apiKey ) throws Exception {
    // Manually set the api key header
    Map < String , String > header = new HashMap < String , String >() { { put ( "x-goog-api-key" , apiKey );}};
    FixedHeaderProvider headerProvider = FixedHeaderProvider . create ( header );

    // Create the client
    TransportChannelProvider transportChannelProvider = InstantiatingHttpJsonChannelProvider . newBuilder (). setHeaderProvider ( headerProvider ). build ();
    LanguageServiceSettings settings = LanguageServiceSettings . newBuilder (). setTransportChannelProvider ( transportChannelProvider ). build ();
    LanguageServiceClient client = LanguageServiceClient . create ( settings );
    return client ;
  }

การแก้ไขปัญหา

หากต้องการความช่วยเหลือ ให้ทำตามคำแนะนำในเอกสารการแก้ไขปัญหา

การกำหนดค่าพร็อกซี

ไลบรารีไคลเอ็นต์ Google Cloud ใช้ HTTPS และ gRPC ในการสื่อสารพื้นฐานกับบริการ ในโปรโตคอลทั้งสอง คุณสามารถกำหนดค่าพร็อกซีโดยใช้คุณสมบัติ https.proxyHost และ (ไม่บังคับ) https.proxyPort

การกำหนดค่าพร็อกซีที่กำหนดเอง gRPC

สำหรับพร็อกซีที่กำหนดเองเพิ่มเติมด้วย gRPC คุณจะต้องจัดหา ProxyDetector ให้กับ ManagedChannelBuilder :

 import com . google . api . core . ApiFunction ;
import com . google . api . gax . rpc . TransportChannelProvider ;
import com . google . cloud . tasks . v2 . CloudTasksClient ;
import com . google . cloud . tasks . v2 . CloudTasksSettings ;
import com . google . cloud . tasks . v2 . stub . CloudTasksStubSettings ;
import io . grpc . HttpConnectProxiedSocketAddress ;
import io . grpc . ManagedChannelBuilder ;
import io . grpc . ProxiedSocketAddress ;
import io . grpc . ProxyDetector ;

import javax . annotation . Nullable ;
import java . io . IOException ;
import java . net . InetSocketAddress ;
import java . net . SocketAddress ;

public CloudTasksClient getService () throws IOException {
  TransportChannelProvider transportChannelProvider =
      CloudTasksStubSettings . defaultGrpcTransportProviderBuilder ()
          . setChannelConfigurator (
              new ApiFunction < ManagedChannelBuilder , ManagedChannelBuilder >() {
                @ Override
                public ManagedChannelBuilder apply ( ManagedChannelBuilder managedChannelBuilder ) {
                  return managedChannelBuilder . proxyDetector (
                      new ProxyDetector () {
                        @ Nullable
                        @ Override
                        public ProxiedSocketAddress proxyFor ( SocketAddress socketAddress )
                            throws IOException {
                          return HttpConnectProxiedSocketAddress . newBuilder ()
                              . setUsername ( PROXY_USERNAME )
                              . setPassword ( PROXY_PASSWORD )
                              . setProxyAddress ( new InetSocketAddress ( PROXY_HOST , PROXY_PORT ))
                              . setTargetAddress (( InetSocketAddress ) socketAddress )
                              . build ();
                        }
                      });
                }
              })
          . build ();
  CloudTasksSettings cloudTasksSettings =
      CloudTasksSettings . newBuilder ()
          . setTransportChannelProvider ( transportChannelProvider )
          . build ();
  return CloudTasksClient . create ( cloudTasksSettings );
}

การดำเนินงานที่ยาวนาน

การดำเนินการที่ใช้เวลานาน (LRO) มักใช้สำหรับการเรียก API ที่คาดว่าจะใช้เวลานานในการดำเนินการให้เสร็จสมบูรณ์ (เช่น การจัดเตรียมอินสแตนซ์ GCE หรือไปป์ไลน์ Dataflow) การเรียก API เริ่มต้นจะสร้าง "การดำเนินการ" บนเซิร์ฟเวอร์และส่งกลับรหัสการดำเนินการเพื่อติดตามความคืบหน้า LRO RPC มีส่วนต่อท้าย Async ต่อท้ายชื่อการโทร (เช่น clusterControllerClient.createClusterAsync() )

ไคลเอนต์ที่สร้างขึ้นของเรามีอินเทอร์เฟซที่ดีสำหรับการเริ่มต้นการดำเนินการและรอให้การดำเนินการเสร็จสิ้น ซึ่งสามารถทำได้โดยการส่งคืน OperationFuture เมื่อเรียก get() บน OperationFuture ไลบรารีไคลเอนต์จะสำรวจการดำเนินการเพื่อตรวจสอบสถานะของการดำเนินการ

ตัวอย่างเช่น ใช้ตัวอย่าง createCluster Operation ใน google-cloud-dataproc v4.20.0:

 try ( ClusterControllerClient clusterControllerClient = ClusterControllerClient . create ()) {
  CreateClusterRequest request =
      CreateClusterRequest . newBuilder ()
          . setProjectId ( "{PROJECT_ID}" )
          . setRegion ( "{REGION}" )
          . setCluster ( Cluster . newBuilder (). build ())
          . setRequestId ( "{REQUEST_ID}" )
          . setActionOnFailedPrimaryWorkers ( FailureAction . forNumber ( 0 ))
          . build ();
  OperationFuture < Cluster , ClusterOperationMetadata > future =
      clusterControllerClient . createClusterOperationCallable (). futureCall ( request );
  // Do something.
  Cluster response = future . get ();
} catch ( CancellationException e ) {
  // Exceeded the default RPC timeout without the Operation completing.
  // Library is no longer polling for the Operation status. Consider 
  // increasing the timeout.
}

LRO หมดเวลา

การดำเนินการโพลมีการหมดเวลาเริ่มต้นซึ่งแตกต่างกันไปในแต่ละบริการ ไลบรารีจะส่ง java.util.concurrent.CancellationException พร้อมข้อความ: Task was cancelled. หากการหมดเวลาเกินการดำเนินการ CancellationException ไม่ได้หมายความว่าการดำเนินการ GCP แบ็กเอนด์ถูกยกเลิก ข้อยกเว้นนี้ถูกส่งออกจากไลบรารีไคลเอ็นต์เมื่อเกินการหมดเวลาทั้งหมดโดยไม่ได้รับสถานะสำเร็จจากการดำเนินการ ไลบรารีไคลเอนต์ของเราเคารพค่าที่กำหนดค่าไว้ใน OperationTimedPollAlgorithm สำหรับแต่ละ RPC

หมายเหตุ: ไลบรารีไคลเอ็นต์จะจัดการกลไกการโพลของ Operation ให้กับคุณ โดยค่าเริ่มต้น ไม่จำเป็นต้องสำรวจสถานะด้วยตนเอง

ค่า LRO เริ่มต้น

LRO RPC แต่ละตัวมีชุดค่าเริ่มต้นที่กำหนดไว้ล่วงหน้า คุณสามารถค้นหาค่าเหล่านี้ได้โดยการค้นหาในคลาสของ StubSettings ของลูกค้าแต่ละราย การตั้งค่า LRO เริ่มต้นจะเริ่มต้นได้ภายในเมธอด initDefaults() ในคลาส Builder ที่ซ้อนกัน

ตัวอย่างเช่น ใน google-cloud-aiplatform v3.24.0 OperationTimedPollAlgorithm เริ่มต้นจะมีค่าเริ่มต้นเหล่านี้:

 OperationTimedPollAlgorithm . create (
    RetrySettings . newBuilder ()
        . setInitialRetryDelay ( Duration . ofMillis ( 5000L ))
        . setRetryDelayMultiplier ( 1.5 )
        . setMaxRetryDelay ( Duration . ofMillis ( 45000L ))
        . setInitialRpcTimeout ( Duration . ZERO )
        . setRpcTimeoutMultiplier ( 1.0 )
        . setMaxRpcTimeout ( Duration . ZERO )
        . setTotalTimeout ( Duration . ofMillis ( 300000L ))
        . build ())

ทั้งการลองใหม่และ LRO ใช้คลาส RetrySettings เดียวกัน สังเกตลิงค์ที่เกี่ยวข้อง:

• การหมดเวลาทั้งหมด (เวลาสูงสุดที่อนุญาตสำหรับการโพล): 5 นาที
• การหน่วงเวลาการลองใหม่ครั้งแรก (การหน่วงเวลาเริ่มต้นก่อนการโพลครั้งแรก): 5 วินาที
• Max Retry Delay (ความล่าช้าสูงสุดระหว่างแต่ละโพล): 45 วินาที
• ลองตัวคูณความล่าช้าอีกครั้ง (ค่าตัวคูณเพื่อเพิ่มความล่าช้าในการโพล): 1.5

ค่าการหมดเวลา RPC ไม่มีประโยชน์ใน LRO และสามารถละเว้นหรือตั้งค่าเป็นค่าเริ่มต้นได้ ( Duration.ZERO สำหรับการหมดเวลาหรือ 1.0 สำหรับตัวคูณ)

การกำหนดค่าการหมดเวลา LRO

หากต้องการกำหนดค่า LRO ให้สร้างออบเจ็กต์ OperationTimedPollAlgorithm และอัปเดตอัลกอริทึมการโพลของ RPC ตัวอย่างเช่น:

 ClusterControllerSettings . Builder settingsBuilder = ClusterControllerSettings . newBuilder ();
TimedRetryAlgorithm timedRetryAlgorithm = OperationTimedPollAlgorithm . create (
		RetrySettings . newBuilder ()
				. setInitialRetryDelay ( Duration . ofMillis ( 500L ))
				. setRetryDelayMultiplier ( 1.5 )
				. setMaxRetryDelay ( Duration . ofMillis ( 5000L ))
				. setInitialRpcTimeout ( Duration . ZERO ) // ignored
				. setRpcTimeoutMultiplier ( 1.0 ) // ignored
				. setMaxRpcTimeout ( Duration . ZERO ) // ignored
				. setTotalTimeout ( Duration . ofHours ( 24L ))	// set polling timeout to 24 hours
				. build ());
settingsBuilder . createClusterOperationSettings ()
		. setPollingAlgorithm ( timedRetryAlgorithm );
ClusterControllerClient clusterControllerClient = ClusterControllerClient . create ( settingsBuilder . build ());

หมายเหตุ: การกำหนดค่าด้านบนจะแก้ไข เฉพาะ ค่า LRO สำหรับ createClusterOperation RPC RPC อื่นๆ ในไคลเอนต์จะยังคงใช้ค่า LRO ที่กำหนดค่าไว้ล่วงหน้าของ RPC แต่ละค่า

การจัดการการพึ่งพา

หากคุณใช้ไลบรารีไคลเอ็นต์ Google Cloud มากกว่าหนึ่งไลบรารี เราขอแนะนำให้คุณใช้หนึ่งใน Bill of Material (BOM) ของเราเพื่อช่วยจัดการเวอร์ชันที่ขึ้นต่อกัน สำหรับข้อมูลเพิ่มเติม โปรดดูที่การใช้ Cloud Client Libraries

เวอร์ชันจาวา

ต้องใช้ Java 8 หรือสูงกว่าเพื่อใช้ไคลเอ็นต์ในพื้นที่เก็บข้อมูลนี้

แพลตฟอร์มที่รองรับ

ไคลเอ็นต์ในพื้นที่เก็บข้อมูลนี้ใช้ HTTP หรือ gRPC สำหรับเลเยอร์การขนส่ง ไคลเอนต์ที่ใช้ HTTP ทั้งหมดควรทำงานในทุกสภาพแวดล้อม

สำหรับไคลเอนต์ที่ใช้ gRPC แพลตฟอร์มที่รองรับจะถูกจำกัดโดยแพลตฟอร์มที่ Forked Tomcat Native รองรับ ซึ่งสำหรับสถาปัตยกรรมหมายถึง x86_64 เท่านั้น และสำหรับระบบปฏิบัติการหมายถึง Mac OS X, Windows และ Linux นอกจากนี้ gRPC ยังจำกัดการใช้แพลตฟอร์มที่มีข้อจำกัดด้านเธรด

จึงไม่รองรับสิ่งต่อไปนี้:

• หุ่นยนต์
  • พิจารณา Firebase ซึ่งมี API เหล่านี้จำนวนมาก
  • คุณสามารถใช้ไลบรารีเหล่านี้ได้ในหลายกรณี แม้ว่าจะไม่รองรับก็ตาม คุณสามารถค้นหาตัวอย่างเช่นนี้ได้ในพื้นที่เก็บข้อมูลตัวอย่างนี้ แต่ให้พิจารณาความเสี่ยงอย่างรอบคอบก่อนที่จะใช้ไลบรารีเหล่านี้ในแอปพลิเคชัน
• Raspberry Pi (เนื่องจากทำงานบนสถาปัตยกรรม ARM)
• Google App Engine มาตรฐาน Java 7

สภาพแวดล้อมต่อไปนี้ควรใช้งานได้ (เหนือสิ่งอื่นใด):

• Windows แบบสแตนด์อโลนบน x86_64
• Mac OS X แบบสแตนด์อโลนบน x86_64
• Linux แบบสแตนด์อโลนบน x86_64
• Google Compute Engine (GCE)
• Google คอนเทนเนอร์เอ็นจิ้น (GKE)
• Google App Engine มาตรฐาน Java 8 (GAE Std J8)
• Google App Engine Flex (GAE Flex)
• อัลไพน์ลินุกซ์ (Java 11+)

การทดสอบ

ไลบรารีนี้มีเครื่องมือเพื่อช่วยเขียนการทดสอบโค้ดที่ใช้บริการ Google-Cloud

ดูการทดสอบเพื่ออ่านเพิ่มเติมเกี่ยวกับการใช้ตัวช่วยการทดสอบของเรา

การกำหนดเวอร์ชัน

ไลบรารีนี้เป็นไปตามการกำหนดเวอร์ชันแบบ Semantic โดยมีคุณสมบัติเพิ่มเติมบางประการ:

1. ส่วนประกอบที่มีเครื่องหมาย @BetaApi หรือ @Experimental ถือเป็นคุณสมบัติ "0.x" ภายในไลบรารี "1.x" ซึ่งหมายความว่าพวกเขาสามารถเปลี่ยนแปลงระหว่างรุ่นรองและรุ่นแพทช์ในลักษณะที่เข้ากันไม่ได้ คุณลักษณะเหล่านี้ไม่ควรถูกใช้โดยไลบรารี "B" ใดๆ ที่ตัวเองมีผู้บริโภค เว้นแต่ส่วนประกอบของไลบรารี B ที่ใช้คุณลักษณะ @BetaApi จะมีเครื่องหมาย @BetaApi ด้วย คุณลักษณะที่ทำเครื่องหมายเป็น @BetaApi อยู่บนเส้นทางที่จะกลายเป็นคุณลักษณะ "1.x" ในที่สุดโดยที่เครื่องหมายถูกลบออก

   ข้อยกเว้นพิเศษสำหรับ google-cloud-java : google-cloud-java ได้รับอนุญาตให้ขึ้นอยู่กับคุณสมบัติ @BetaApi ใน gax-java โดยไม่ต้องประกาศรหัสการบริโภค @BetaApi เนื่องจาก gax-java และ google-cloud-java เคลื่อนไหวเป็นขั้นตอนซึ่งกันและกัน . ด้วยเหตุนี้ gax-java จึงไม่ควรใช้แยกจาก google-cloud-java

2. ส่วนประกอบที่ทำเครื่องหมายด้วย @InternalApi นั้นเป็นสาธารณะทางเทคนิค แต่เพียงเพราะข้อจำกัดของตัวดัดแปลงการเข้าถึงของ Java เพื่อวัตถุประสงค์ของ semver ควรพิจารณาว่าเป็นส่วนตัว

3. อินเทอร์เฟซที่ทำเครื่องหมายด้วย @InternalExtensionOnly เป็นแบบสาธารณะ แต่ควรใช้โดยคลาสภายในเท่านั้น เพื่อวัตถุประสงค์ของ semver เราขอสงวนสิทธิ์ในการเพิ่มอินเทอร์เฟซเหล่านี้โดยไม่มีการใช้งานเริ่มต้น (สำหรับ Java 7)

โปรดทราบว่าลูกค้าเหล่านี้กำลังอยู่ระหว่างการพัฒนา รุ่นใดๆ ที่เป็นเวอร์ชัน 0.xy อาจมีการเปลี่ยนแปลงที่เข้ากันไม่ได้แบบย้อนหลังได้ตลอดเวลา

มั่นคง

ไลบรารีที่กำหนดในระดับคุณภาพที่เสถียรนั้นคาดว่าจะมีเสถียรภาพ และการอัปเดตทั้งหมดในไลบรารีนั้นรับประกันว่าจะเข้ากันได้แบบย้อนหลัง การเปลี่ยนแปลงที่เข้ากันไม่ได้แบบย้อนหลังจะนำไปสู่การเพิ่มเวอร์ชันหลัก (1.xy -> 2.0.0)

ดูตัวอย่าง

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

ปลั๊กอิน IDE

หากคุณใช้ IntelliJ หรือ Eclipse คุณสามารถเพิ่มไลบรารีไคลเอ็นต์ให้กับโปรเจ็กต์ของคุณโดยใช้ปลั๊กอิน IDE เหล่านี้:

• เครื่องมือคลาวด์สำหรับ IntelliJ
• เครื่องมือคลาวด์สำหรับ Eclipse

นอกจากการเพิ่มไลบรารีไคลเอ็นต์แล้ว ปลั๊กอินยังมีฟังก์ชันเพิ่มเติม เช่น การจัดการคีย์บัญชีบริการ โปรดดูเอกสารประกอบสำหรับปลั๊กอินแต่ละตัวสำหรับรายละเอียดเพิ่มเติม

ไลบรารีไคลเอ็นต์เหล่านี้สามารถใช้กับมาตรฐาน App Engine สำหรับรันไทม์ Java 8 และ App Engine ที่ยืดหยุ่นได้ (รวมถึงรันไทม์ของ Compat) ไลบรารีส่วนใหญ่ไม่ทำงานบนมาตรฐาน App Engine สำหรับรันไทม์ Java 7 อย่างไรก็ตาม Datastore, Storage และ Bigquery ควรใช้งานได้

มีส่วนร่วม

เรายินดีต้อนรับและสนับสนุนการบริจาคให้กับห้องสมุดแห่งนี้เสมอ

ดูเอกสารประกอบของ google-cloud และเอกสารที่ใช้ร่วมกันสำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีเริ่มต้นใช้งาน

โปรดทราบว่าโครงการนี้เผยแพร่พร้อมกับจรรยาบรรณของผู้ร่วมให้ข้อมูล การเข้าร่วมในโครงการนี้แสดงว่าคุณตกลงที่จะปฏิบัติตามข้อกำหนดของโครงการ ดูหลักจรรยาบรรณสำหรับข้อมูลเพิ่มเติม

ใบอนุญาต

Apache 2.0 - ดูใบอนุญาตสำหรับข้อมูลเพิ่มเติม