คำขอที่ส่งไปยัง FCM จากเซิร์ฟเวอร์ของแอปหรือสภาพแวดล้อมที่เชื่อถือได้ ต้องได้รับอนุญาต โปรดสังเกตความแตกต่างที่สำคัญระหว่างการเลิกใช้งาน การให้สิทธิ์ HTTP API และ HTTP v1 API เดิม:
- FCM HTTP v1 API จะให้สิทธิ์คำขอที่มี โทเค็นเพื่อการเข้าถึง OAuth 2.0 ซึ่งมีอายุการใช้งานสั้น หากต้องการสร้างโทเค็นนี้ คุณสามารถใช้แอปพลิเคชัน Google ข้อมูลเข้าสู่ระบบเริ่มต้น (ในสภาพแวดล้อมของเซิร์ฟเวอร์ Google) และ/หรือรับด้วยตนเอง ข้อมูลเข้าสู่ระบบที่จำเป็น จากไฟล์คีย์ส่วนตัว JSON ที่สร้างขึ้นสำหรับบัญชีบริการ หากคุณใช้ Firebase Admin SDK ในการส่งข้อความ ไลบรารีจะจัดการโทเค็นให้คุณ
- โปรโตคอลเดิมที่เลิกใช้งานแล้วจะใช้ได้เฉพาะคีย์ API ที่ใช้ได้นานที่ได้รับมาเท่านั้น จากคอนโซล Firebase
ให้สิทธิ์คำขอส่ง HTTP v1
ขึ้นอยู่กับรายละเอียดของ สภาพแวดล้อมของเซิร์ฟเวอร์ ใช้กลยุทธ์เหล่านี้ร่วมกันเพื่อให้สิทธิ์เซิร์ฟเวอร์ คำขอไปยังบริการ Firebase:
- ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน Google (ADC)
- ไฟล์ JSON ของบัญชีบริการ
- โทเค็นเพื่อการเข้าถึง OAuth 2.0 ที่มีอายุสั้น ซึ่งได้มาจากบัญชีบริการ
หากแอปพลิเคชันของคุณทำงานอยู่ในวันที่ Compute Engine Google Kubernetes Engine, App Engine หรือ Cloud Functions (รวมถึง Cloud Functions for Firebase) ให้ใช้ Application Default Credentials (ADC) ADC ใช้บริการเริ่มต้นที่มีอยู่ของคุณ เพื่อรับข้อมูลรับรองเพื่อให้สิทธิ์คำขอ และ ADC จะเปิดใช้ การทดสอบภายในที่ยืดหยุ่นผ่านตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS เพื่อระบบอัตโนมัติเต็มรูปแบบ ขั้นตอนการให้สิทธิ์ ให้ใช้ ADC ร่วมกับไลบรารีเซิร์ฟเวอร์ Admin SDK
หากแอปพลิเคชันของคุณทำงานบนสภาพแวดล้อมของเซิร์ฟเวอร์ที่ไม่ใช่ Google คุณจะต้องดาวน์โหลดไฟล์ JSON ของบัญชีบริการจากโปรเจ็กต์ Firebase ตราบใดที่คุณมีสิทธิ์เข้าถึงระบบไฟล์ที่มี ไฟล์คีย์ส่วนตัว คุณสามารถใช้ตัวแปรสภาพแวดล้อมได้ GOOGLE_APPLICATION_CREDENTIALSเพื่อให้สิทธิ์คำขอ ด้วยข้อมูลเข้าสู่ระบบที่ได้มาด้วยตนเอง หากขาด คุณต้องอ้างอิงไฟล์บัญชีบริการในโค้ด ซึ่งควรดำเนินการด้วยความระมัดระวังอย่างยิ่ง เนื่องจากมีความเสี่ยงต่อการเปิดเผยข้อมูลประจำตัวของคุณ
ระบุข้อมูลเข้าสู่ระบบโดยใช้ ADC
ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน Google (ADC) จะตรวจสอบข้อมูลเข้าสู่ระบบของคุณ ตามลำดับต่อไปนี้
ADC จะตรวจสอบว่าตัวแปรสภาพแวดล้อม ตั้งค่า GOOGLE_APPLICATION_CREDENTIALS แล้ว หากมีการตั้งค่าตัวแปรแล้ว โดย ADC จะใช้ไฟล์บัญชีบริการที่ตัวแปรชี้ไป
หากไม่ได้ตั้งค่าตัวแปรสภาพแวดล้อม ADC จะใช้บัญชีบริการเริ่มต้น ที่ Compute Engine, Google Kubernetes Engine, App Engine และ Cloud Functions จะมีให้บริการแก่แอปพลิเคชันที่ทำงานบนบริการเหล่านั้น
หาก ADC ใช้ข้อมูลเข้าสู่ระบบรายการใดรายการหนึ่งข้างต้นไม่ได้ ระบบจะแสดงข้อผิดพลาด
ตัวอย่างโค้ด Admin SDK ต่อไปนี้แสดงให้เห็นถึงกลยุทธ์นี้ ตัวอย่าง ไม่ได้ระบุข้อมูลเข้าสู่ระบบของแอปพลิเคชันอย่างชัดเจน อย่างไรก็ตาม ADC สามารถ ค้นหาข้อมูลเข้าสู่ระบบโดยปริยายตราบใดที่มีการตั้งค่าตัวแปรสภาพแวดล้อม หรือ ตราบใดที่แอปพลิเคชันยังทำงานอยู่ใน Compute Engine Google Kubernetes Engine, App Engine หรือ Cloud Functions
Node.js
admin.initializeApp({
credential: admin.credential.applicationDefault(),
});
Java
FirebaseOptions options = FirebaseOptions.builder()
.setCredentials(GoogleCredentials.getApplicationDefault())
.setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
.build();
FirebaseApp.initializeApp(options);
Python
default_app = firebase_admin.initialize_app()
Go
app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
C#
FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.GetApplicationDefault(),
});
ระบุข้อมูลเข้าสู่ระบบด้วยตนเอง
โปรเจ็กต์ Firebase รองรับ Google บัญชีบริการ ซึ่งใช้เพื่อเรียกใช้ Firebase ได้ API ของเซิร์ฟเวอร์จากเซิร์ฟเวอร์ของแอปหรือสภาพแวดล้อมที่เชื่อถือได้ หากคุณกำลังพัฒนา โค้ดภายในเครื่อง หรือการทำให้แอปพลิเคชันใช้งานได้ภายในองค์กร คุณสามารถใช้ข้อมูลเข้าสู่ระบบที่ได้รับ ผ่านบัญชีบริการนี้เพื่อให้สิทธิ์คำขอของเซิร์ฟเวอร์
วิธีตรวจสอบสิทธิ์และให้สิทธิ์บัญชีบริการ ในการเข้าถึงบริการ Firebase คุณต้องสร้างไฟล์คีย์ส่วนตัวใน JSON
วิธีสร้างไฟล์คีย์ส่วนตัวสำหรับบัญชีบริการ
ในคอนโซล Firebase ให้เปิด การตั้งค่า > บัญชีบริการ
คลิกสร้างคีย์ส่วนตัวใหม่ แล้วยืนยันโดยคลิกสร้างคีย์
จัดเก็บไฟล์ JSON ที่มีคีย์ดังกล่าวอย่างปลอดภัย
เมื่อให้สิทธิ์ผ่านบัญชีบริการ คุณมี 2 ตัวเลือกในการระบุ ลงในแอปพลิเคชันของคุณ คุณสามารถตั้ง GOOGLE_APPLICATION_CREDENTIALS ตัวแปรสภาพแวดล้อม หรือคุณอาจ ส่งผ่านเส้นทางไปยังคีย์บัญชีบริการในโค้ดอย่างชัดแจ้ง ตัวเลือกแรกมีความปลอดภัยกว่าและขอแนะนำอย่างยิ่ง
วิธีตั้งค่าตัวแปรสภาพแวดล้อม
ตั้งค่าตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS ไปยังเส้นทางไฟล์ของไฟล์ JSON ที่มีคีย์บัญชีบริการ ตัวแปรนี้ใช้ได้กับเซสชัน Shell ปัจจุบันเท่านั้น ดังนั้นหากคุณเปิด ให้กำหนดตัวแปรอีกครั้ง
Linux หรือ macOS
export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"
Windows
ด้วย PowerShell:
$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"
หลังจากทำตามขั้นตอนข้างต้นเสร็จแล้ว ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน (ADC) สามารถระบุข้อมูลประจำตัวของคุณโดยนัย ซึ่งทำให้คุณสามารถใช้บริการ ข้อมูลเข้าสู่ระบบบัญชีเมื่อทดสอบหรือทำงานในสภาพแวดล้อมที่ไม่ใช่ Google
ใช้ข้อมูลเข้าสู่ระบบเพื่อสร้างโทเค็นเพื่อการเข้าถึง
เว้นแต่ว่าคุณกำลังใช้ Admin SDK ซึ่งจัดการการให้สิทธิ์โดยอัตโนมัติ คุณจะต้องสร้างโทเค็นเพื่อการเข้าถึง แล้วเพิ่มเพื่อส่งคำขอ
ใช้ข้อมูลเข้าสู่ระบบ Firebase ร่วมกับ ไลบรารีการตรวจสอบสิทธิ์ของ Google สำหรับภาษาที่ต้องการเพื่อเรียกโทเค็นเพื่อการเข้าถึง OAuth 2.0 ที่มีอายุสั้น:
Node.js
function getAccessToken() {
return new Promise(function(resolve, reject) {
const key = require('../placeholders/service-account.json');
const jwtClient = new google.auth.JWT(
key.client_email,
null,
key.private_key,
SCOPES,
null
);
jwtClient.authorize(function(err, tokens) {
if (err) {
reject(err);
return;
}
resolve(tokens.access_token);
});
});
}
ในตัวอย่างนี้ ไลบรารีของไคลเอ็นต์ Google API จะตรวจสอบสิทธิ์คำขอด้วย โทเค็นเว็บ JSON หรือ JWT สำหรับข้อมูลเพิ่มเติม โปรดดู โทเค็นเว็บ JSON
Python
def _get_access_token():
"""Retrieve a valid access token that can be used to authorize requests.
:return: Access token.
"""
credentials = service_account.Credentials.from_service_account_file(
'service-account.json', scopes=SCOPES)
request = google.auth.transport.requests.Request()
credentials.refresh(request)
return credentials.token
Java
private static String getAccessToken() throws IOException {
GoogleCredentials googleCredentials = GoogleCredentials
.fromStream(new FileInputStream("service-account.json"))
.createScoped(Arrays.asList(SCOPES));
googleCredentials.refresh();
return googleCredentials.getAccessToken().getTokenValue();
}
หลังจากที่โทเค็นเพื่อการเข้าถึงหมดอายุ ระบบจะเรียกวิธีการรีเฟรชโทเค็น โดยอัตโนมัติเพื่อเรียกโทเค็นเพื่อการเข้าถึงที่อัปเดตแล้ว
หากต้องการให้สิทธิ์เข้าถึง FCM ให้ส่งคำขอขอบเขต
https://www.googleapis.com/auth/firebase.messaging
วิธีเพิ่มโทเค็นเพื่อการเข้าถึงในส่วนหัวของคำขอ HTTP
เพิ่มโทเค็นเป็นค่าของส่วนหัว Authorization
ในรูปแบบ
Authorization: Bearer <access_token>
:
Node.js
headers: {
'Authorization': 'Bearer ' + accessToken
}
Python
headers = {
'Authorization': 'Bearer ' + _get_access_token(),
'Content-Type': 'application/json; UTF-8',
}
Java
URL url = new URL(BASE_URL + FCM_SEND_ENDPOINT);
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
httpURLConnection.setRequestProperty("Authorization", "Bearer " + getServiceAccountAccessToken());
httpURLConnection.setRequestProperty("Content-Type", "application/json; UTF-8");
return httpURLConnection;
ให้สิทธิ์คำขอในการส่งผ่านโปรโตคอลเดิม
เมื่อใช้โปรโตคอลเดิมของ HTTP คำขอแต่ละรายการจะต้องมีคีย์เซิร์ฟเวอร์จาก แท็บ Cloud Messaging ของการตั้งค่าคอนโซล Firebase แผง สําหรับ XMPP คุณต้องใช้คีย์เซิร์ฟเวอร์เดียวกันเพื่อสร้างการเชื่อมต่อ
ย้ายข้อมูลคีย์เซิร์ฟเวอร์เดิม
ตั้งแต่เดือนมีนาคม 2020 เป็นต้นมา FCM ได้หยุดสร้างคีย์เซิร์ฟเวอร์เดิม คีย์เซิร์ฟเวอร์เดิมที่มีอยู่จะยังคงทำงานต่อไป แต่เราขอแนะนำให้คุณ ให้ใช้คีย์เวอร์ชันใหม่ที่มีป้ายกำกับว่าคีย์เซิร์ฟเวอร์ใน คอนโซล Firebase
หากต้องการลบคีย์เซิร์ฟเวอร์เดิมที่มีอยู่ คุณสามารถทำได้ใน คอนโซล Google Cloud
ให้สิทธิ์คำขอ HTTP
คำขอข้อความประกอบด้วย 2 ส่วน ได้แก่ ส่วนหัว HTTP และเนื้อหา HTTP ส่วนหัว HTTP ต้องมีส่วนหัวต่อไปนี้
Authorization
: key=YOUR_SERVER_KEY
ตรวจสอบว่าเป็นคีย์เซิร์ฟเวอร์ซึ่งมีค่า มีให้บริการใน แท็บ Cloud Messaging ในแผงการตั้งค่าของคอนโซล Firebase Android, แพลตฟอร์ม Apple และคีย์เบราว์เซอร์ถูกปฏิเสธโดย FCMContent-Type
:application/json
สำหรับ JSONapplication/x-www-form-urlencoded;charset=UTF-8
สำหรับข้อความธรรมดา
หากไม่ใส่Content-Type
รูปแบบ จะถือว่าเป็นข้อความธรรมดา
เช่น
Content-Type:application/json Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA { "to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...", "data" : { ... }, }
โปรดดู สร้างคำขอส่งคำขอเพื่อดูรายละเอียดทั้งหมดในการสร้างคำขอส่ง การอ้างอิงโปรโตคอล HTTP เดิม จะแสดงรายการพารามิเตอร์ทั้งหมดที่ข้อความจะมีได้
การตรวจสอบความถูกต้องของคีย์เซิร์ฟเวอร์
หากได้รับข้อผิดพลาดด้านการตรวจสอบสิทธิ์เมื่อส่งข้อความ โปรดตรวจสอบความถูกต้อง ของคีย์เซิร์ฟเวอร์ เช่น ใน Linux ให้เรียกใช้คำสั่งต่อไปนี้
api_key=YOUR_SERVER_KEY curl --header "Authorization: key=$api_key" \ --header Content-Type:"application/json" \ https://fcm.googleapis.com/fcm/send \ -d "{\"registration_ids\":[\"ABC\"]}"
หากคุณได้รับรหัสสถานะ HTTP 401 แสดงว่าคีย์เซิร์ฟเวอร์ไม่ถูกต้อง
ให้สิทธิ์การเชื่อมต่อ XMPP
ด้วย XMPP คุณสามารถรักษา การเชื่อมต่ออย่างต่อเนื่อง แบบไม่พร้อมกัน แบบ 2 ทิศทางกับเซิร์ฟเวอร์ FCM สามารถใช้การเชื่อมต่อ เพื่อรับส่งข้อความระหว่างเซิร์ฟเวอร์กับ ผู้ใช้ของคุณ อุปกรณ์ที่เชื่อมต่อกับ FCM
คุณใช้พื้นที่ส่วนใหญ่
ไลบรารี XMPP เพื่อจัดการการเชื่อมต่อนานกับ FCM ปลายทาง XMPP ทำงานที่
fcm-xmpp.googleapis.com:5235
เมื่อทำการทดสอบ
กับผู้ใช้ที่ไม่ได้ใช้งานจริง คุณควรเชื่อมต่อกับเซิร์ฟเวอร์รุ่นก่อนใช้งานจริงที่
fcm-xmpp.googleapis.com:5236
(โปรดสังเกตพอร์ตอื่น)
การทดสอบปกติในเวอร์ชันก่อนที่ใช้งานจริง (สภาพแวดล้อมที่เล็กลงซึ่งบิลด์ FCM ล่าสุดทำงานอยู่)
มีประโยชน์ในการแยกผู้ใช้จริงออกจากโค้ดทดสอบ ทดสอบอุปกรณ์และทดสอบรหัสที่เชื่อมต่อกับ
fcm-xmpp.googleapis.com:5236
ควรใช้รหัสผู้ส่ง FCM อื่นเพื่อหลีกเลี่ยงความเสี่ยง
การส่งข้อความทดสอบไปยังผู้ใช้เวอร์ชันที่ใช้งานจริง หรือการส่งข้อความอัปสตรีมจากการรับส่งข้อมูลเวอร์ชันที่ใช้งานจริง
ผ่านการเชื่อมต่อทดสอบ
การเชื่อมต่อมีข้อกําหนดที่สำคัญ 2 ประการดังนี้
- คุณต้องเริ่มการเชื่อมต่อ Transport Layer Security (TLS) โปรดทราบว่า ปัจจุบัน FCM ไม่รองรับSTARTส่วนขยาย TLS
- FCM กำหนดให้ใช้กลไกการตรวจสอบสิทธิ์ SASL PLAIN โดยใช้
<your_FCM_Sender_Id>@fcm.googleapis.com
(FCM รหัสผู้ส่ง) และคีย์เซิร์ฟเวอร์เป็นรหัสผ่าน ค่าเหล่านี้ได้แก่ มีอยู่ใน แท็บ Cloud Messaging ในแผงการตั้งค่าคอนโซล Firebase
หากการเชื่อมต่อล้มเหลวในช่วงเวลาใด คุณต้องเชื่อมต่อใหม่ทันที ไม่จำเป็นต้องปิดการเชื่อมต่อหลังจากยกเลิกการเชื่อมต่อ การตรวจสอบสิทธิ์ สำหรับรหัสผู้ส่งแต่ละรายการ FCM อนุญาตให้มีการเชื่อมต่อ 2,500 รายการแบบขนาน
ข้อมูลโค้ดต่อไปนี้จะแสดงวิธีตรวจสอบสิทธิ์และ การให้สิทธิ์สำหรับการเชื่อมต่อ XMPP กับ FCM
เซิร์ฟเวอร์ XMPP
เซิร์ฟเวอร์ XMPP ขอการเชื่อมต่อกับ FCM
<stream:stream to="fcm.googleapis.com" version="1.0" xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams">
FCM
FCM จะเปิดการเชื่อมต่อและขอกลไกการตรวจสอบสิทธิ์ รวมถึง
PLAIN
วิธี
<stream:features> <mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"> <mechanism>X-OAUTH2</mechanism> <mechanism>X-GOOGLE-TOKEN</mechanism> <mechanism>PLAIN</mechanism> </mechanisms> </stream:features>
เซิร์ฟเวอร์ XMPP
เซิร์ฟเวอร์ XMPP ต้องตอบกลับโดยใช้วิธีการตรวจสอบสิทธิ์ PLAIN
โดยระบุคีย์เซิร์ฟเวอร์จาก
แท็บ Cloud Messaging ในแผงการตั้งค่าของคอนโซล Firebase
<auth mechanism="PLAIN" xmlns="urn:ietf:params:xml:ns:xmpp-sasl">MTI2MjAwMzQ3OTMzQHByb2plY3RzLmdjbS5hb mFTeUIzcmNaTmtmbnFLZEZiOW1oekNCaVlwT1JEQTJKV1d0dw==</auth>
FCM
<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>
เซิร์ฟเวอร์ XMPP
<stream:stream to="fcm.googleapis.com" version="1.0" xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams">
FCM
<stream:features> <bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"/> <session xmlns="urn:ietf:params:xml:ns:xmpp-session"/> </stream:features>
เซิร์ฟเวอร์ XMPP
<iq type="set"> <bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"></bind> </iq>
FCM
<iq type="result"> <bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"> <jid>SENDER_ID@fcm.googleapis.com/RESOURCE</jid> </bind> </iq>
หมายเหตุ: FCM ไม่ได้ใช้ทรัพยากรที่เชื่อมโยงขณะกำหนดเส้นทางข้อความ
โปรดดู สร้างคำขอส่งคำขอเพื่อดูรายละเอียดทั้งหมดในการสร้างคำขอส่ง การอ้างอิงโปรโตคอล XMPP เดิม จะแสดงรายการพารามิเตอร์ทั้งหมดที่ข้อความจะมีได้