คำขอที่ส่งไปยัง FCM จากเซิร์ฟเวอร์ของแอปหรือสภาพแวดล้อมที่เชื่อถือได้ต้องได้รับอนุญาต โปรดดูความแตกต่างที่สำคัญระหว่างการให้สิทธิ์ HTTP API เดิมที่เลิกใช้งานแล้วและการให้สิทธิ์ API ของ HTTP v1 ดังต่อไปนี้
- 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) ให้ใช้ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน (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 ซึ่งคุณสามารถใช้เพื่อเรียก API ของเซิร์ฟเวอร์ Firebase จากเซิร์ฟเวอร์แอปหรือสภาพแวดล้อมที่เชื่อถือได้ หากคุณกำลังพัฒนาโค้ดในเครื่องหรือทำให้แอปพลิเคชันใช้งานได้ภายในองค์กร คุณจะใช้ข้อมูลเข้าสู่ระบบที่ได้รับผ่านบัญชีบริการนี้เพื่อให้สิทธิ์คำขอของเซิร์ฟเวอร์ได้
หากต้องการตรวจสอบสิทธิ์บัญชีบริการและให้สิทธิ์เข้าถึงบริการ 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 Console
ให้สิทธิ์คำขอ HTTP
คำขอข้อความประกอบด้วย 2 ส่วน ได้แก่ ส่วนหัว 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\"]}"
หากคุณได้รับรหัสสถานะ 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 ยังไม่รองรับส่วนขยาย STARTTLS
- 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 เดิมจะแสดงรายการพารามิเตอร์ทั้งหมดที่ข้อความมีได้