คำขอที่ส่งไปยัง FCM จากเซิร์ฟเวอร์แอปหรือสภาพแวดล้อมที่เชื่อถือได้ต้องได้รับอนุญาต สังเกตความแตกต่างที่สำคัญเหล่านี้ระหว่างการอนุญาต HTTP ดั้งเดิมและ 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 Application Default Credentials (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()
ไป
app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
log.Fatalf("error initializing app: %v\n", err)
}
ค#
FirebaseApp.Create(new AppOptions()
{
Credential = GoogleCredential.GetApplicationDefault(),
});
ระบุข้อมูลประจำตัวด้วยตนเอง
โปรเจ็กต์ Firebase รองรับ บัญชีบริการ ของ Google ซึ่งคุณสามารถใช้เรียก API เซิร์ฟเวอร์ Firebase จากเซิร์ฟเวอร์แอปหรือสภาพแวดล้อมที่เชื่อถือได้ หากคุณกำลังพัฒนาโค้ดในเครื่องหรือปรับใช้แอปพลิเคชันภายในองค์กร คุณสามารถใช้ข้อมูลรับรองที่ได้รับผ่านบัญชีบริการนี้เพื่ออนุมัติคำขอของเซิร์ฟเวอร์
หากต้องการตรวจสอบสิทธิ์บัญชีบริการและอนุญาตให้เข้าถึงบริการ Firebase คุณต้องสร้างไฟล์คีย์ส่วนตัวในรูปแบบ JSON
ในการสร้างไฟล์คีย์ส่วนตัวสำหรับบัญชีบริการของคุณ:
ในคอนโซล Firebase เปิด การตั้งค่า > บัญชีบริการ
คลิก สร้างคีย์ส่วนตัวใหม่ จากนั้นยืนยันโดยคลิก สร้างคีย์
จัดเก็บไฟล์ JSON ที่มีคีย์อย่างปลอดภัย
เมื่อให้สิทธิ์ผ่านบัญชีบริการ คุณมีสองทางเลือกในการให้ข้อมูลประจำตัวแก่แอปพลิเคชันของคุณ คุณสามารถตั้งค่าตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS หรือคุณสามารถส่งเส้นทางไปยังรหัสบัญชีบริการอย่างชัดเจน ตัวเลือกแรกมีความปลอดภัยมากกว่าและขอแนะนำอย่างยิ่ง
การตั้งค่าตัวแปรสภาพแวดล้อม:
ตั้งค่าตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS เป็นเส้นทางไฟล์ของไฟล์ JSON ที่มีคีย์บัญชีบริการของคุณ ตัวแปรนี้ใช้กับเชลล์เซสชันปัจจุบันของคุณเท่านั้น ดังนั้นหากคุณเปิดเซสชันใหม่ ให้ตั้งค่าตัวแปรอีกครั้ง
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"
หลังจากที่คุณทำตามขั้นตอนข้างต้นเสร็จสิ้นแล้ว Application Default Credentials (ADC) จะสามารถระบุข้อมูลประจำตัวของคุณโดยปริยาย ซึ่งช่วยให้คุณใช้ข้อมูลประจำตัวของบัญชีบริการเมื่อทำการทดสอบหรือใช้งานในสภาพแวดล้อมที่ไม่ใช่ของ Google
ใช้ข้อมูลประจำตัวเพื่อสร้างโทเค็นการเข้าถึง
เว้นแต่ว่าคุณกำลังใช้ Admin SDK ซึ่งจัดการการให้สิทธิ์โดยอัตโนมัติ คุณจะต้องสร้างโทเค็นเพื่อการเข้าถึงและเพิ่มเพื่อส่งคำขอ
ใช้ข้อมูลรับรอง Firebase ร่วมกับ Google Auth Library สำหรับภาษาที่คุณต้องการเพื่อดึงโทเค็นการเข้าถึง 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 = ServiceAccountCredentials.from_json_keyfile_name(
'service-account.json', SCOPES)
access_token_info = credentials.get_access_token()
return access_token_info.access_token
Java
private static String getAccessToken() throws IOException {
GoogleCredentials googleCredentials = GoogleCredentials
.fromStream(new FileInputStream("service-account.json"))
.createScoped(Arrays.asList(SCOPES));
googleCredentials.refreshAccessToken();
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 " + getAccessToken());
httpURLConnection.setRequestProperty("Content-Type", "application/json; UTF-8");
return httpURLConnection;
อนุญาตโปรโตคอลดั้งเดิมส่งคำขอ
ด้วยโปรโตคอล HTTP ดั้งเดิม คำขอแต่ละรายการต้องมีคีย์เซิร์ฟเวอร์จากแท็บ Cloud Messaging ของแผง การตั้งค่า คอนโซล Firebase สำหรับ XMPP คุณต้องใช้คีย์เซิร์ฟเวอร์เดียวกันเพื่อสร้างการเชื่อมต่อ
ย้ายข้อมูลคีย์เซิร์ฟเวอร์เดิม
ตั้งแต่เดือนมีนาคม 2020 FCM จะหยุดสร้างคีย์เซิร์ฟเวอร์เดิม คีย์เซิร์ฟเวอร์เดิมที่มีอยู่จะยังคงทำงานต่อไป แต่เราขอแนะนำให้คุณใช้เวอร์ชันที่ใหม่กว่าของคีย์ที่ชื่อ รหัส เซิร์ฟเวอร์ ใน คอนโซล Firebase
หากคุณต้องการลบคีย์เซิร์ฟเวอร์เดิมที่มีอยู่ คุณสามารถทำได้ใน Google Cloud Console
อนุญาตคำขอ HTTP
คำขอข้อความประกอบด้วยสองส่วน: ส่วนหัว HTTP และเนื้อหา HTTP ส่วนหัว HTTP ต้องมีส่วนหัวต่อไปนี้:
-
Authorization
: key=YOUR_SERVER_KEY
ตรวจสอบให้แน่ใจว่านี่คือคีย์ เซิร์ฟเวอร์ ซึ่งมีค่าอยู่ในแท็บ Cloud Messaging ของบานหน้าต่าง การตั้งค่า คอนโซล Firebase FCM ปฏิเสธ Android, แพลตฟอร์ม Apple และเบราว์เซอร์ -
Content-Type
:application/json
สำหรับ JSON;application/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\"]}"
หากคุณได้รับรหัสสถานะ 401 HTTP แสดงว่ารหัสเซิร์ฟเวอร์ของคุณไม่ถูกต้อง
อนุญาตการเชื่อมต่อ XMPP
ด้วย XMPP คุณสามารถรักษาการเชื่อมต่อแบบสองทิศทางแบบต่อเนื่องแบบอะซิงโครนัสกับเซิร์ฟเวอร์ FCM สามารถใช้การเชื่อมต่อเพื่อส่งและรับข้อความระหว่างเซิร์ฟเวอร์ของคุณและอุปกรณ์ที่เชื่อมต่อกับ FCM ของผู้ใช้
คุณสามารถใช้ไลบรารี XMPP ส่วนใหญ่เพื่อจัดการการเชื่อมต่อที่มีอายุการใช้งานยาวนานกับ FCM ปลายทาง XMPP ทำงานที่ fcm-xmpp.googleapis.com:5235
เมื่อทดสอบการทำงานกับผู้ใช้ที่ไม่ได้ใช้งานจริง คุณควรเชื่อมต่อกับเซิร์ฟเวอร์รุ่นก่อนการผลิตที่ fcm-xmpp.googleapis.com:5236
(สังเกตพอร์ตอื่น)
การทดสอบก่อนการผลิตเป็นประจำ (สภาพแวดล้อมที่เล็กกว่าซึ่ง FCM บิลด์ล่าสุดทำงาน) เป็นประโยชน์สำหรับการแยกผู้ใช้จริงออกจากโค้ดทดสอบ อุปกรณ์ทดสอบและรหัสทดสอบที่เชื่อมต่อกับ fcm-xmpp.googleapis.com:5236
ควรใช้ ID ผู้ส่ง FCM อื่นเพื่อหลีกเลี่ยงความเสี่ยงใดๆ ในการส่งข้อความทดสอบไปยังผู้ใช้ที่ใช้งานจริงหรือส่งข้อความอัปสตรีมจากการรับส่งข้อมูลที่ใช้งานจริงผ่านการเชื่อมต่อทดสอบ
การเชื่อมต่อมีข้อกำหนดที่สำคัญสองประการ:
- คุณต้องเริ่มต้นการเชื่อมต่อ Transport Layer Security (TLS) โปรดทราบว่าขณะนี้ FCM ไม่สนับสนุน ส่วนขยาย STARTTLS
- FCM ต้องการกลไกการตรวจสอบสิทธิ์ SASL PLAIN โดยใช้
<your_FCM_Sender_Id>@fcm.googleapis.com
(FCM sender ID ) และคีย์เซิร์ฟเวอร์เป็นรหัสผ่าน ค่าเหล่านี้มีอยู่ในแท็บ Cloud Messaging ของแผง การตั้งค่า คอนโซล Firebase
หากการเชื่อมต่อล้มเหลว คุณควรเชื่อมต่อใหม่ทันที ไม่จำเป็นต้องปิดการทำงานหลังจากการตัดการเชื่อมต่อที่เกิดขึ้นหลังการตรวจสอบสิทธิ์ สำหรับ ID ผู้ส่ง แต่ละราย FCM อนุญาตการเชื่อมต่อ 2500 แบบขนาน
ตัวอย่างต่อไปนี้แสดงวิธีการดำเนินการรับรองความถูกต้องและการอนุญาตสำหรับการเชื่อมต่อ 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
เซิร์ฟเวอร์ PLAIN
ต้องตอบสนองโดยใช้วิธีการตรวจสอบสิทธิ์แบบธรรมดา โดยระบุคีย์เซิร์ฟเวอร์จากแท็บการ รับส่งข้อความบนคลาวด์ ของแผง การตั้งค่า คอนโซล 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 รุ่นเก่า แสดงรายการพารามิเตอร์ทั้งหมดที่ข้อความของคุณสามารถมีได้