การใช้ AWS AppSync และ AWS Lake Formation เพื่อเข้าถึง Data Lake ที่ปลอดภัยผ่าน GraphQL API | อเมซอนเว็บเซอร์วิส

Data Lake ได้รับความนิยมในการจัดเก็บข้อมูลจำนวนมหาศาลจากแหล่งที่มาที่หลากหลายด้วยวิธีที่ปรับขนาดได้และคุ้มต้นทุน เมื่อจำนวนผู้ใช้ข้อมูลเพิ่มมากขึ้น ผู้ดูแลระบบ Data Lake มักจะต้องใช้การควบคุมการเข้าถึงแบบละเอียดสำหรับโปรไฟล์ผู้ใช้ที่แตกต่างกัน พวกเขาอาจจำเป็นต้องจำกัดการเข้าถึงบางตารางหรือคอลัมน์ ขึ้นอยู่กับประเภทของผู้ใช้ที่ส่งคำขอ นอกจากนี้ ธุรกิจบางครั้งต้องการให้แอปพลิเคชันภายนอกเข้าถึงข้อมูลได้ แต่ไม่แน่ใจว่าจะทำอย่างไรอย่างปลอดภัย เพื่อจัดการกับความท้าทายเหล่านี้ องค์กรต่างๆ สามารถหันมาใช้ GraphQL และ การก่อตัวของทะเลสาบ AWS.

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

ผู้ดูแลระบบ Data Lake สามารถใช้ Lake Formation เพื่อควบคุมการเข้าถึง Data Lake Lake Formation นำเสนอการควบคุมการเข้าถึงแบบละเอียดสำหรับการจัดการสิทธิ์ของผู้ใช้และกลุ่มที่ระดับตาราง คอลัมน์ และเซลล์ จึงสามารถรับประกันความปลอดภัยของข้อมูลและการปฏิบัติตามข้อกำหนดได้ นอกจากนี้ Lake Formation นี้ยังทำงานร่วมกับบริการอื่นๆ ของ AWS เช่น อเมซอน อาเธน่าทำให้เหมาะอย่างยิ่งสำหรับการสืบค้น Data Lake ผ่าน API

ในโพสต์นี้ เราจะสาธิตวิธีสร้างแอปพลิเคชันที่สามารถดึงข้อมูลจาก Data Lake ผ่าน GraphQL API และส่งมอบผลลัพธ์ให้กับผู้ใช้ประเภทต่างๆ ตามสิทธิ์การเข้าถึงข้อมูลเฉพาะของพวกเขา แอปพลิเคชันตัวอย่างที่อธิบายในโพสต์นี้สร้างโดย AWS Partner เทคโนโลยี เน็ตโซล.

ภาพรวมโซลูชัน

โซลูชันของเราใช้ บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) เพื่อจัดเก็บข้อมูล AWS กาว Data Catalog เพื่อจัดเก็บสคีมาของข้อมูล และ Lake Formation เพื่อให้การกำกับดูแลออบเจ็กต์ AWS Glue Data Catalog โดยการใช้การเข้าถึงตามบทบาท เรายังใช้ อเมซอน EventBridge เพื่อบันทึกเหตุการณ์ใน Data Lake ของเราและเปิดตัวกระบวนการดาวน์สตรีม สถาปัตยกรรมโซลูชันจะแสดงอยู่ในแผนภาพต่อไปนี้

รูปที่ 1 – สถาปัตยกรรมโซลูชัน

ต่อไปนี้เป็นคำอธิบายทีละขั้นตอนของโซลูชัน:

1. Data Lake ถูกสร้างขึ้นในบัคเก็ต S3 ที่ลงทะเบียนกับ Lake Formation เมื่อใดก็ตามที่มีข้อมูลใหม่เข้ามา กฎ EventBridge จะถูกเรียกใช้
2. กฎ EventBridge รันไฟล์ AWS แลมบ์ดา ฟังก์ชันเพื่อเริ่มโปรแกรมรวบรวมข้อมูล AWS Glue เพื่อค้นหาข้อมูลใหม่และอัปเดตการเปลี่ยนแปลงสคีมาเพื่อให้สามารถสืบค้นข้อมูลล่าสุดได้
   หมายเหตุ: โปรแกรมรวบรวมข้อมูล AWS Glue สามารถเปิดใช้งานได้โดยตรงจากเหตุการณ์ Amazon S3 ตามที่อธิบายไว้ในนี้ โพสต์บล็อก.
3. AWS ขยาย อนุญาตให้ผู้ใช้ลงชื่อเข้าใช้งาน Amazon Cognito Co ในฐานะผู้ให้บริการข้อมูลประจำตัว Cognito ตรวจสอบข้อมูลประจำตัวของผู้ใช้และส่งคืนโทเค็นการเข้าถึง
4. ผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์จะเรียกใช้ AWS AppSync GraphQL API ผ่าน Amplify โดยดึงข้อมูลจาก Data Lake ฟังก์ชัน Lambda ทำงานเพื่อจัดการกับคำขอ
5. ฟังก์ชัน Lambda ดึงรายละเอียดผู้ใช้จาก Cognito และถือว่า AWS Identity และการจัดการการเข้าถึง (IAM) บทบาทที่เกี่ยวข้องกับกลุ่มผู้ใช้ Cognito ของผู้ใช้ที่ร้องขอ
6. จากนั้นฟังก์ชัน Lambda จะเรียกใช้การสืบค้น Athena กับตาราง Data Lake และส่งคืนผลลัพธ์ไปยัง AWS AppSync ซึ่งจะส่งคืนผลลัพธ์ให้กับผู้ใช้

เบื้องต้น

หากต้องการปรับใช้โซลูชันนี้ คุณต้องดำเนินการดังต่อไปนี้ก่อน:

git clone git@github.com:aws-samples/aws-appsync-with-lake-formation.git
cd aws-appsync-with-lake-formation

เตรียมการอนุญาตการสร้างทะเลสาบ

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

รูปที่ 2 – เพิ่มตัวคุณเองเป็นผู้ดูแล Lake Formation

หรือคุณสามารถเลือกบทบาทผู้ดูแลระบบและงานในแถบนำทางด้านซ้าย และเลือกจัดการผู้ดูแลระบบเพื่อเพิ่มตัวคุณเอง คุณควรเห็นชื่อผู้ใช้ IAM ของคุณภายใต้ผู้ดูแลระบบ Data Lake ที่มีสิทธิ์การเข้าถึงแบบเต็มเมื่อดำเนินการเสร็จสิ้น

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

รูปที่ 3 – การตั้งค่าแค็ตตาล็อกข้อมูลการก่อตัวของทะเลสาบ

ปรับใช้โซลูชัน

หากต้องการสร้างโซลูชันในสภาพแวดล้อม AWS ของคุณ ให้เปิดใช้สแต็ก AWS CloudFormation ต่อไปนี้:  

ทรัพยากรต่อไปนี้จะเปิดตัวผ่านเทมเพลต CloudFormation:

• Amazon VPC และส่วนประกอบเครือข่าย (ซับเน็ต กลุ่มความปลอดภัย และเกตเวย์ NAT)
• บทบาท IAM
• Lake Formation ที่ห่อหุ้มบัคเก็ต S3, โปรแกรมรวบรวมข้อมูล AWS Glue และฐานข้อมูล AWS Glue
• ฟังก์ชั่นแลมบ์ดา
• กลุ่มผู้ใช้ Cognito
• AWS AppSync GraphQL API
• กฎ EventBridge

หลังจากปรับใช้ทรัพยากรที่ต้องการจากสแต็ก CloudFormation แล้ว คุณต้องสร้างฟังก์ชัน Lambda สองฟังก์ชันและอัปโหลดชุดข้อมูลไปยัง Amazon S3 Lake Formation จะควบคุม Data Lake ที่ถูกจัดเก็บไว้ในบัคเก็ต S3

สร้างฟังก์ชันแลมบ์ดา

เมื่อใดก็ตามที่มีการวางไฟล์ใหม่ลงในบัคเก็ต S3 ที่กำหนด กฎ EventBridge จะถูกเรียกใช้ ซึ่งเปิดใช้ฟังก์ชัน Lambda เพื่อเริ่มต้นโปรแกรมรวบรวมข้อมูล AWS Glue โปรแกรมรวบรวมข้อมูลจะอัปเดต AWS Glue Data Catalog เพื่อให้สอดคล้องกับการเปลี่ยนแปลงใดๆ ในสคีมา

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

หากต้องการสร้างฟังก์ชัน Lambda ทั้งสองนี้ ให้ดำเนินการดังนี้

1. ลงชื่อเข้าใช้คอนโซล Lambda
2. เลือกฟังก์ชัน Lambda ของตัวจัดการคำขอที่มีชื่อ dl-dev-crawlerLambdaFunction.
3. ค้นหาไฟล์ฟังก์ชัน Lambda ของโปรแกรมรวบรวมข้อมูลในไฟล์ lambdas/crawler-lambda โฟลเดอร์ใน repo git ที่คุณโคลนไปยังเครื่องของคุณ
4. คัดลอกและวางโค้ดในไฟล์นั้นไปยังส่วนโค้ดของ dl-dev-crawlerLambdaFunction ในคอนโซล Lambda ของคุณ จากนั้นเลือก Deploy เพื่อปรับใช้ฟังก์ชัน

รูปที่ 4 – คัดลอกและวางโค้ดลงในฟังก์ชัน Lambda

5. ทำซ้ำขั้นตอนที่ 2 ถึง 4 สำหรับฟังก์ชันตัวจัดการคำขอที่มีชื่อ dl-dev-requestHandlerLambdaFunction โดยใช้โค้ดใน lambdas/request-handler-lambda.

สร้างเลเยอร์สำหรับตัวจัดการคำขอ Lambda

ตอนนี้คุณต้องอัปโหลดโค้ดไลบรารีเพิ่มเติมที่จำเป็นสำหรับฟังก์ชัน Lambda ของตัวจัดการคำขอ

1. เลือก เลเยอร์ ในเมนูด้านซ้ายแล้วเลือก สร้างเลเยอร์.
2. ใส่ชื่อเช่น appsync-lambda-layer.
3. ดาวน์โหลดนี้ ไฟล์ ZIP ของเลเยอร์แพ็คเกจ ไปยังเครื่องท้องถิ่นของคุณ
4. อัปโหลดไฟล์ ZIP โดยใช้ไฟล์ อัพโหลด ปุ่มบน สร้างเลเยอร์ หน้า.
5. Choose งูหลาม 3.7 เป็นรันไทม์สำหรับเลเยอร์
6. Choose สร้างบัญชีตัวแทน.
7. เลือก ฟังก์ชั่น บนเมนูด้านซ้ายและเลือก dl-dev-requestHandler ฟังก์ชันแลมบ์ดา
8. เลื่อนลงไปที่ เลเยอร์ ส่วนและเลือก เพิ่มเลเยอร์.
9. เลือก เลเยอร์ที่กำหนดเอง จากนั้นเลือกเลเยอร์ที่คุณสร้างไว้ด้านบน
10. คลิก เพิ่ม.

อัปโหลดข้อมูลไปยัง Amazon S3

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

รูปที่ 5 – ชื่อบัคเก็ต S3 ที่แสดงในแท็บ CloudFormation Outputs

ป้อนคำสั่งต่อไปนี้ในโฟลเดอร์โปรเจ็กต์ของคุณในเครื่องภายในเพื่ออัปโหลดชุดข้อมูลไปยังบัคเก็ต S3

cd dataset
aws s3 cp . s3://bucket_name/ --recursive

ตอนนี้เรามาดูสิ่งประดิษฐ์ที่ปรับใช้แล้ว

ทะเลสาบข้อมูล

บัคเก็ต S3 เก็บข้อมูลตัวอย่างสำหรับสองเอนทิตี: บริษัทและเจ้าของที่เกี่ยวข้อง บัคเก็ตได้รับการลงทะเบียนกับ Lake Formation ดังแสดงในรูปที่ 6 ซึ่งจะช่วยให้ Lake Formation สามารถสร้างและจัดการแค็ตตาล็อกข้อมูลและจัดการสิทธิ์ในข้อมูลได้

รูปที่ 6 – คอนโซล Lake Formation แสดงตำแหน่งของ Data Lake

ฐานข้อมูลถูกสร้างขึ้นเพื่อเก็บสคีมาของข้อมูลที่มีอยู่ใน Amazon S3 โปรแกรมรวบรวมข้อมูล AWS Glue ใช้เพื่ออัปเดตการเปลี่ยนแปลงใดๆ ในสคีมาในบัคเก็ต S3 โปรแกรมรวบรวมข้อมูลนี้ได้รับอนุญาตให้สร้างตาราง ALTER และ DROP ในฐานข้อมูลโดยใช้ Lake Formation

ใช้การควบคุมการเข้าถึง Data Lake

มีการสร้างบทบาท IAM สองบทบาท dl-us-east-1-developer และ dl-us-east-1-business-analystซึ่งแต่ละกลุ่มถูกกำหนดให้กับกลุ่มผู้ใช้ Cognito ที่แตกต่างกัน แต่ละบทบาทจะได้รับการมอบหมายการอนุญาตที่แตกต่างกันผ่าน Lake Formation บทบาทนักพัฒนาจะได้รับสิทธิ์เข้าถึงทุกคอลัมน์ใน Data Lake ในขณะที่บทบาทนักวิเคราะห์ธุรกิจจะได้รับสิทธิ์ในการเข้าถึงเฉพาะคอลัมน์ข้อมูลที่ไม่สามารถระบุตัวตนได้ (PII) เท่านั้น

รูปที่ 7 –สิทธิ์อนุญาต Data Lake ของคอนโซล Lake Formation ที่กำหนดให้กับบทบาทกลุ่ม

สคีมา GraphQL

GraphQL API สามารถดูได้จากคอนโซล AWS AppSync ที่ Companies type มีแอตทริบิวต์หลายรายการที่อธิบายเจ้าของบริษัท

รูปที่ 8 – สคีมาสำหรับ GraphQL API

แหล่งข้อมูลสำหรับ GraphQL API คือฟังก์ชัน Lambda ซึ่งจัดการคำขอ

รูปที่ 9 – แหล่งข้อมูล AWS AppSync ที่แมปกับฟังก์ชัน Lambda

การจัดการคำขอ GraphQL API

ฟังก์ชัน Lambda ตัวจัดการคำขอ GraphQL API จะดึง ID พูลผู้ใช้ Cognito จากตัวแปรสภาพแวดล้อม การใช้ไลบรารี boto3 คุณสร้างไคลเอ็นต์ Cognito และใช้ get_group วิธีการรับบทบาท IAM ที่เกี่ยวข้องกับกลุ่มผู้ใช้ Cognito

คุณใช้ฟังก์ชันตัวช่วยในฟังก์ชัน Lambda เพื่อรับบทบาท

def get_cognito_group_role(group_name): response = cognito_idp_client.get_group( GroupName=group_name, UserPoolId=cognito_user_pool_id ) print(response) role_arn = response.get('Group').get('RoleArn') return role_arn

การใช้ บริการโทเค็นความปลอดภัย AWS (AWS STS) ผ่านไคลเอ็นต์ boto3 คุณสามารถรับบทบาท IAM และรับข้อมูลรับรองชั่วคราวที่จำเป็นในการเรียกใช้การสืบค้น Athena

def get_temp_creds(role_arn): response = sts_client.assume_role( RoleArn=role_arn, RoleSessionName='stsAssumeRoleAthenaQuery', ) return response['Credentials']['AccessKeyId'],
response['Credentials']['SecretAccessKey'], response['Credentials']['SessionToken']

เราส่งข้อมูลประจำตัวชั่วคราวเป็นพารามิเตอร์เมื่อสร้างไคลเอ็นต์ Boto3 Amazon Athena ของเรา

athena_client = boto3.client('athena', aws_access_key_id=access_key, aws_secret_access_key=secret_key, aws_session_token=session_token)

ไคลเอนต์และการสืบค้นจะถูกส่งผ่านไปยังฟังก์ชันตัวช่วยการสืบค้น Athena ของเรา ซึ่งดำเนินการสืบค้นและส่งกลับรหัสการสืบค้น ด้วย ID แบบสอบถาม เราสามารถอ่านผลลัพธ์จาก S3 และรวมเป็นพจนานุกรม Python เพื่อส่งคืนในการตอบกลับ

def get_query_result(s3_client, output_location): bucket, object_key_path = get_bucket_and_path(output_location) response = s3_client.get_object(Bucket=bucket, Key=object_key_path) status = response.get("ResponseMetadata", {}).get("HTTPStatusCode") result = [] if status == 200: print(f"Successful S3 get_object response. Status - {status}") df = pandas.read_csv(response.get("Body")) df = df.fillna('') result = df.to_dict('records') print(result) else: print(f"Unsuccessful S3 get_object response. Status - {status}") return result

การเปิดใช้งานการเข้าถึง Data Lake ฝั่งไคลเอ็นต์

ในฝั่งไคลเอ็นต์ AWS Amplify ได้รับการกำหนดค่าด้วยพูลผู้ใช้ Amazon Cognito สำหรับการตรวจสอบสิทธิ์ เราจะไปที่คอนโซล Amazon Cognito เพื่อดูกลุ่มผู้ใช้และกลุ่มที่สร้างขึ้น

รูปที่ 10 –กลุ่มผู้ใช้ Amazon Cognito

สำหรับแอปพลิเคชันตัวอย่างของเรา เรามีกลุ่มผู้ใช้สองกลุ่ม:

• dl-dev-businessAnalystUserGroup – นักวิเคราะห์ธุรกิจที่มีสิทธิ์จำกัด
• dl-dev-developerUserGroup – นักพัฒนาที่มีสิทธิ์เต็มรูปแบบ

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

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

หลังจากที่ผู้ใช้ได้รับการตรวจสอบและรับรองความถูกต้องโดย Cognito แล้ว Amplify จะใช้โทเค็นการเข้าถึงเพื่อเรียกใช้ AWS AppSync GraphQL API และดึงข้อมูล ขึ้นอยู่กับกลุ่มของผู้ใช้ ฟังก์ชัน Lambda จะรับบทบาทกลุ่มผู้ใช้ Cognito ที่สอดคล้องกัน เมื่อใช้บทบาทสมมติ ระบบจะเรียกใช้แบบสอบถาม Athena และผลลัพธ์จะส่งคืนให้กับผู้ใช้

สร้างผู้ใช้ทดสอบ

สร้างผู้ใช้สองคน คนหนึ่งสำหรับนักพัฒนาและอีกคนหนึ่งสำหรับนักวิเคราะห์ธุรกิจ และเพิ่มพวกเขาลงในกลุ่มผู้ใช้

1. ไปที่ Cognito และเลือกกลุ่มผู้ใช้ dl-dev-cognitoUserPoolที่สร้างขึ้นแล้ว
2. Choose สร้างผู้ใช้ และระบุรายละเอียดเพื่อสร้างผู้ใช้นักวิเคราะห์ธุรกิจรายใหม่ ชื่อผู้ใช้สามารถเป็นได้ นักวิเคราะห์ธุรกิจ. ปล่อยให้ที่อยู่อีเมลว่างไว้ และป้อนรหัสผ่าน
3. เลือก ผู้ใช้ และเลือกผู้ใช้ที่คุณเพิ่งสร้างขึ้น
4. เพิ่มผู้ใช้รายนี้ในกลุ่มนักวิเคราะห์ธุรกิจโดยเลือก เพิ่มผู้ใช้ในกลุ่ม ปุ่ม
5. ทำตามขั้นตอนเดียวกันเพื่อสร้างผู้ใช้รายอื่นด้วยชื่อผู้ใช้ ผู้พัฒนา และเพิ่มผู้ใช้ในกลุ่มนักพัฒนา

ทดสอบวิธีแก้ปัญหา

หากต้องการทดสอบโซลูชันของคุณ ให้เปิดแอปพลิเคชัน React บนเครื่องของคุณ

1. ในไดเร็กทอรีโปรเจ็กต์โคลน ให้ไปที่ react-app ไดเรกทอรี
2. ติดตั้งการพึ่งพาโครงการ

npm install

3. ติดตั้ง Amplify CLI:

npm install -g @aws-amplify/cli

4. สร้างไฟล์ใหม่ที่เรียกว่า .env โดยรันคำสั่งต่อไปนี้ จากนั้นใช้โปรแกรมแก้ไขข้อความเพื่ออัปเดตค่าตัวแปรสภาพแวดล้อมในไฟล์

echo export REACT_APP_APPSYNC_URL=Your AppSync endpoint URL > .env
echo export REACT_APP_CLIENT_ID=Your Cognito app client ID >> .env
echo export REACT_APP_USER_POOL_ID=Your Cognito user pool ID >> .env

ใช้ Outputs ของสแต็กคอนโซล CloudFormation ของคุณเพื่อรับค่าที่ต้องการจากคีย์ดังต่อไปนี้:

5. เพิ่มตัวแปรก่อนหน้าให้กับสภาพแวดล้อมของคุณ

source .env

6. สร้างโค้ดที่จำเป็นในการโต้ตอบกับ API โดยใช้ ขยาย CodeGen. ในแท็บเอาต์พุตของคอนโซล Cloudformation ให้ค้นหา AWS Appsync API ID ของคุณถัดจาก appsyncApiId กุญแจ

amplify add codegen --apiId <appsyncApiId>

ยอมรับตัวเลือกเริ่มต้นทั้งหมดสำหรับคำสั่งข้างต้นโดยกด เข้าสู่ ในแต่ละพร้อมท์

7. เริ่มแอปพลิเคชัน

คุณสามารถยืนยันได้ว่าแอปพลิเคชันกำลังทำงานอยู่โดยไปที่ http://localhost:3000 และลงชื่อเข้าใช้ในฐานะผู้ใช้นักพัฒนาซอฟต์แวร์ที่คุณสร้างไว้ก่อนหน้านี้

ตอนนี้คุณมีแอปพลิเคชันที่ทำงานอยู่แล้ว มาดูกันว่าแต่ละบทบาทจะได้รับบริการอย่างไร companies จุดสิ้นสุด

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

รูปที่ 11 –ผลลัพธ์สำหรับบทบาทของนักพัฒนา

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

รูปที่ 12 –ผลลัพธ์สำหรับบทบาทนักวิเคราะห์ธุรกิจ

คอลัมน์ชื่อและนามสกุลของรายชื่อบริษัทจะไม่รวมอยู่ในมุมมองนักวิเคราะห์ธุรกิจ แม้ว่าคุณจะทำการร้องขอไปยังจุดสิ้นสุดเดียวกันก็ตาม สิ่งนี้แสดงให้เห็นถึงพลังของการใช้ตำแหน่งข้อมูล GraphQL ที่รวมเป็นหนึ่งเดียวร่วมกับบทบาท IAM กลุ่มผู้ใช้ Cognito หลายบทบาทที่แมปกับสิทธิ์ Lake Formation เพื่อจัดการการเข้าถึงข้อมูลของคุณตามบทบาท

การทำความสะอาด

หลังจากคุณทดสอบโซลูชันเสร็จแล้ว ให้ล้างทรัพยากรต่อไปนี้เพื่อหลีกเลี่ยงการเรียกเก็บเงินในอนาคต:

1. ล้างบัคเก็ต S3 ที่สร้างโดยเทมเพลต CloudFormation
2. ลบสแตก CloudFormation เพื่อลบบัคเก็ต S3 และทรัพยากรอื่นๆ

สรุป

ในโพสต์นี้ เราได้แสดงให้คุณเห็นวิธีการให้บริการข้อมูลอย่างปลอดภัยใน Data Lake แก่ผู้ใช้ที่ได้รับการรับรองความถูกต้องของแอปพลิเคชัน React ตามสิทธิ์การเข้าถึงตามบทบาทของพวกเขา เพื่อให้บรรลุเป้าหมายนี้ คุณใช้ GraphQL API ใน AWS AppSync, การควบคุมการเข้าถึงแบบละเอียดจาก Lake Formation และ Cognito สำหรับการตรวจสอบสิทธิ์ผู้ใช้ตามกลุ่มและแมปผู้ใช้กับบทบาท IAM คุณยังใช้ Athena เพื่อสืบค้นข้อมูลอีกด้วย

สำหรับการอ่านที่เกี่ยวข้องในหัวข้อนี้ โปรดดู การแสดงข้อมูลขนาดใหญ่ด้วย AWS AppSync, Amazon Athena และ AWS Amplify และ ออกแบบสถาปัตยกรรม data mesh โดยใช้ AWS Lake Formation และ AWS Glue.

คุณจะใช้แนวทางนี้ในการให้บริการข้อมูลจาก Data Lake ของคุณหรือไม่? แจ้งให้เราทราบในความคิดเห็น!

เกี่ยวกับผู้เขียน

รานา ดัตต์ เป็น Principal Solutions Architect ที่ Amazon Web Services เขามีพื้นฐานในการออกแบบสถาปัตยกรรมแพลตฟอร์มซอฟต์แวร์ที่ปรับขนาดได้สำหรับบริษัทบริการทางการเงิน การดูแลสุขภาพ และโทรคมนาคม และมีความหลงใหลในการช่วยเหลือลูกค้าสร้างบน AWS

รันชิธ รายาโปรลู เป็นสถาปนิกโซลูชันอาวุโสที่ AWS ที่ทำงานร่วมกับลูกค้าในแปซิฟิกตะวันตกเฉียงเหนือ เขาช่วยลูกค้าออกแบบและดำเนินการโซลูชัน Well-Architected ใน AWS ซึ่งแก้ไขปัญหาทางธุรกิจและเร่งการนำบริการของ AWS ไปใช้ เขามุ่งเน้นไปที่เทคโนโลยีด้านความปลอดภัยและเครือข่ายของ AWS เพื่อพัฒนาโซลูชันในระบบคลาวด์ในอุตสาหกรรมแนวดิ่งต่างๆ Ranjith อาศัยอยู่ในพื้นที่ซีแอตเทิลและชอบกิจกรรมกลางแจ้ง

จัสติน เลโต เป็นสถาปนิกโซลูชันอาวุโสที่ Amazon Web Services โดยมีความเชี่ยวชาญในด้านฐานข้อมูล การวิเคราะห์ Big Data และการเรียนรู้ของเครื่อง ความหลงใหลของเขาคือการช่วยให้ลูกค้านำระบบคลาวด์ไปใช้ได้ดียิ่งขึ้น ในเวลาว่าง เขาสนุกกับการล่องเรือนอกชายฝั่งและเล่นเปียโนแจ๊ส เขาอาศัยอยู่ในนิวยอร์กซิตี้กับภรรยาและลูกสาวตัวน้อยของเขา

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• PlatoData.Network Vertical Generative Ai เพิ่มพลังให้กับตัวเอง เข้าถึงได้ที่นี่.
• เพลโตไอสตรีม. Web3 อัจฉริยะ ขยายความรู้ เข้าถึงได้ที่นี่.
• เพลโตESG. คาร์บอน, คลีนเทค, พลังงาน, สิ่งแวดล้อม แสงอาทิตย์, การจัดการของเสีย. เข้าถึงได้ที่นี่.
• เพลโตสุขภาพ เทคโนโลยีชีวภาพและข่าวกรองการทดลองทางคลินิก เข้าถึงได้ที่นี่.
• ที่มา: https://aws.amazon.com/blogs/big-data/using-aws-appsync-and-aws-lake-formation-to-access-a-secure-data-lake-through-a-graphql-api/