ಸರ್ವಿಸ್ ಕ್ಯಾಟಲಾಗ್ ಡೇಟಾ ಮಾಡೆಲ್ ಮತ್ತು golden path ಟೆಂಪ್ಲೇಟ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಿ

ಪರಿಚಯ

ರಚನಾತ್ಮಕ ಕ್ಯಾಟಲಾಗ್ ಇಲ್ಲದಿದ್ದಾಗ AI ತಂಡಗಳು ಆಡ್-ಹಾಕ್ ಪ್ರೊವಿಷನಿಂಗ್‌ಗೆ ಮೊರೆ ಹೋಗುವುದನ್ನು ಇಂಜಿನಿಯರ್‌ಗಳು ಆಗಾಗ್ಗೆ ಕಾಣುತ್ತಾರೆ—GPU ವೆಚ್ಚ ನಿಯಂತ್ರಣವಿಲ್ಲದೆ ಬೆಳೆಯುತ್ತದೆ, ಮಾಡೆಲ್ ಡಿಪ್ಲಾಯ್‌ಮೆಂಟ್‌ಗಳು ಮಾನಿಟರಿಂಗ್ ಇನ್‌ಸ್ಟ್ರುಮೆಂಟೇಷನ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತವೆ, ಮತ್ತು ಕನೆಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಡಜನ್‌ಗಟ್ಟಲೆ ಸರ್ವಿಸ್‌ಗಳಲ್ಲಿ ಹಾರ್ಡ್‌ಕೋಡ್ ಆಗಿರುತ್ತವೆ, ಅವುಗಳ ನಡುವೆ ಯಾವುದೇ ಸ್ವಯಂಚಾಲಿತ ವೈರಿಂಗ್ ಇರುವುದಿಲ್ಲ. ಗೋಲ್ಡನ್ ಪಾತ್‌ಗಳೊಂದಿಗೆ ಜೋಡಿಸಲಾದ ಸರ್ವಿಸ್ ಕ್ಯಾಟಲಾಗ್ ಇದನ್ನು ಪರಿಹರಿಸುತ್ತದೆ—ತಂಡಗಳಿಗೆ ಪರಿಶೀಲಿಸಲಾದ ಸರ್ವಿಸ್‌ಗಳ ಕ್ಯುರೇಟೆಡ್ ರಿಜಿಸ್ಟ್ರಿ ಮತ್ತು ಮೊದಲೇ ಸಂಯೋಜಿಸಲಾದ ವರ್ಕ್‌ಫ್ಲೋಗಳನ್ನು ನೀಡುವ ಮೂಲಕ, ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ನಿರ್ಧಾರಗಳನ್ನು ಮೊದಲಿನಿಂದ ಮರುಶೋಧಿಸದೆ ಅವುಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಈ ಪಾಠದ ಕೊನೆಯಲ್ಲಿ, ನೋಂದಣಿ ಸಮಯದಲ್ಲಿ ಗವರ್ನೆನ್ಸ್ ನೀತಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸುವ ಕ್ಯಾಟಲಾಗ್ ಡೇಟಾ ಮಾಡೆಲ್ ವಿನ್ಯಾಸಗೊಳಿಸಲು, ಆ ಸರ್ವಿಸ್‌ಗಳನ್ನು ಎಂಡ್-ಟು-ಎಂಡ್ AI ವರ್ಕ್‌ಫ್ಲೋಗಳಾಗಿ ಸಂಯೋಜಿಸುವ ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತಗಳ ಅನುಕ್ರಮವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು, ಮತ್ತು ಪ್ರೊವಿಷನಿಂಗ್ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಂಟ್ರೋಲ್ ಪ್ಲೇನ್ ಮೂಲಕ ಅಂತರ-ಸರ್ವಿಸ್ ಕಾನ್ಫಿಗರೇಷನ್ ಅನ್ನು ಹೇಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರಸಾರ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನೀವು ಸಮರ್ಥರಾಗುತ್ತೀರಿ.

ಪ್ರಮುಖ ಪರಿಭಾಷೆ

• Service Catalog (ಸರ್ವಿಸ್ ಕ್ಯಾಟಲಾಗ್): ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಒದಗಿಸುವ ಸರ್ವಿಸ್‌ಗಳ ಕ್ಯುರೇಟೆಡ್ ರಿಜಿಸ್ಟ್ರಿ; ಪ್ರತಿಯೊಂದೂ ಅದರ ಸಾಮರ್ಥ್ಯಗಳು, SLAಗಳು, ಅವಲಂಬನೆಗಳು ಮತ್ತು ಪ್ರೊವಿಷನಿಂಗ್ ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ವಿವರಿಸುವ ಮೆಟಾಡೇಟಾವನ್ನು ಹೊಂದಿರುತ್ತದೆ.
• Golden Path (ಗೋಲ್ಡನ್ ಪಾತ್): ನಿರ್ದಿಷ್ಟ ಬಳಕೆಯ ಪ್ರಕರಣಕ್ಕಾಗಿ ಹಲವು ಕ್ಯಾಟಲಾಗ್ ಸರ್ವಿಸ್‌ಗಳನ್ನು ಎಂಡ್-ಟು-ಎಂಡ್ ಪೈಪ್‌ಲೈನ್ ಆಗಿ ಸಂಯೋಜಿಸುವ, ಮೊದಲೇ ಪರಿಶೀಲಿಸಲಾದ, ನಿರ್ದಿಷ್ಟ ಅಭಿಪ್ರಾಯವುಳ್ಳ ವರ್ಕ್‌ಫ್ಲೋ ಟೆಂಪ್ಲೇಟ್.
• Service Template (ಸರ್ವಿಸ್ ಟೆಂಪ್ಲೇಟ್): ನಿರ್ದಿಷ್ಟ ಸರ್ವಿಸ್ ಇನ್‌ಸ್ಟೆನ್ಸ್‌ಗಾಗಿ ಇನ್‌ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್-ಆಸ್-ಕೋಡ್ ಮತ್ತು ಕಾನ್ಫಿಗರೇಷನ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವ ಪ್ಯಾರಾಮೀಟರೈಸ್ಡ್ ಬ್ಲೂಪ್ರಿಂಟ್.
• Platform Control Plane (ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಂಟ್ರೋಲ್ ಪ್ಲೇನ್): ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಾದ್ಯಂತ ಸರ್ವಿಸ್ ಜೀವನಚಕ್ರ, ಕಾನ್ಫಿಗರೇಷನ್ ಪ್ರಸಾರ ಮತ್ತು ಆರೋಗ್ಯ ಮಾನಿಟರಿಂಗ್ ಅನ್ನು ನಿರ್ವಹಿಸುವ APIಗಳು ಮತ್ತು ಕಂಟ್ರೋಲರ್‌ಗಳ ಸಮೂಹ.
• Catalog Entry (ಕ್ಯಾಟಲಾಗ್ ಎಂಟ್ರಿ): ಕ್ಯಾಟಲಾಗ್‌ನೊಳಗಿನ ಒಂದೇ ಸರ್ವಿಸ್ ವ್ಯಾಖ್ಯಾನ; ಅದರ ಸ್ಕೀಮಾ, ಆವೃತ್ತಿ ಇತಿಹಾಸ, ಮಾಲೀಕತ್ವದ ಮೆಟಾಡೇಟಾ ಮತ್ತು ಅವಲಂಬನೆ ಗ್ರಾಫ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.

ಪರಿಕಲ್ಪನೆಗಳು

ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಾನ್ಫಿಗರೇಷನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್‌ಗೆ ಸಂಪರ್ಕಿಸುವುದು

ಸರ್ವಿಸ್ ಕ್ಯಾಟಲಾಗ್ ಮತ್ತು ಗೋಲ್ಡನ್ ಪಾತ್ ರಿಜಿಸ್ಟ್ರಿ ಪ್ರತ್ಯೇಕವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ—ಅವು ಸಂಬಂಧಿತ ಲ್ಯಾಬ್ ಉದ್ದೇಶದಲ್ಲಿ ವಿವರಿಸಲಾದ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಾನ್ಫಿಗರೇಷನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಸರ್ವಿಸ್‌ಗೆ ನೇರವಾಗಿ ಆಹಾರ ನೀಡುತ್ತವೆ. ಪ್ರೊವಿಷನಿಂಗ್ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತದಿಂದ ಸರ್ವಿಸ್ ಅನ್ನು ಡಿಪ್ಲಾಯ್ ಮಾಡಿದಾಗ, ಅದು ಪರಿಣಾಮವಾಗಿ ಬರುವ ಕಾನ್ಫಿಗರೇಷನ್ ಅನ್ನು (ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳು, ಕ್ರೆಡೆನ್ಷಿಯಲ್ ರೆಫರೆನ್ಸ್‌ಗಳು, ರಿಸೋರ್ಸ್ ಹಂಚಿಕೆಗಳು) Redis ಕ್ಯಾಶಿಂಗ್‌ನೊಂದಿಗೆ PostgreSQL ಗೆ ಬರೆಯುತ್ತದೆ. ಗೋಲ್ಡನ್ ಪಾತ್‌ನ ನಂತರದ ಸರ್ವಿಸ್‌ಗಳು ತಮ್ಮ ಹಿಂದಿನವುಗಳ ಕಾನ್ಫಿಗರೇಷನ್ ಅನ್ನು ಈ ಸ್ಟೋರ್‌ನಿಂದ ಓದುತ್ತವೆ, ಇದು ಸ್ವಯಂಚಾಲಿತ ವೈರಿಂಗ್ ಅನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತ 1 ರಲ್ಲಿ ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪ್ರೊವಿಷನ್ ಮಾಡಿದಾಗ, ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಡೇಟಾಬೇಸ್‌ನ ಕನೆಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಕಲೆಕ್ಷನ್ ಸ್ಕೀಮಾವನ್ನು ಕಾನ್ಫಿಗರೇಷನ್ ಸ್ಟೋರ್‌ಗೆ platform/team-alpha/vector-db/qdrant/connection ನಂತಹ ನೇಮ್‌ಸ್ಪೇಸ್ಡ್ ಕೀ ಅಡಿಯಲ್ಲಿ ಬರೆಯುತ್ತದೆ. ಹಂತ 2 ಮಾಡೆಲ್ ಸರ್ವಿಂಗ್ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಪ್ರೊವಿಷನ್ ಮಾಡಿದಾಗ, ಸರ್ವಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನ ಸ್ಟಾರ್ಟ್‌ಅಪ್ ಕಾನ್ಫಿಗರೇಷನ್ ಎಂಬೆಡ್ಡಿಂಗ್ ಲುಕಪ್‌ಗಳನ್ನು ಎಲ್ಲಿಗೆ ಕಳುಹಿಸಬೇಕು ಎಂದು ಕಂಡುಹಿಡಿಯಲು ಅದೇ ಕೀಯನ್ನು ಓದುತ್ತದೆ. ಈ ಪ್ಯಾಟರ್ನ್ ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಿದ ಕನೆಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ನಿವಾರಿಸುತ್ತದೆ ಮತ್ತು ಗ್ರಾಹಕ ಕೋಡ್ ಬದಲಾವಣೆಗಳ ಅಗತ್ಯವಿಲ್ಲದೆ ಕ್ರೆಡೆನ್ಷಿಯಲ್‌ಗಳನ್ನು ರೊಟೇಟ್ ಮಾಡಲು ಅಥವಾ ಸರ್ವಿಸ್‌ಗಳನ್ನು ವಲಸೆ ಮಾಡಲು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಕಾನ್ಫಿಗರೇಷನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಸರ್ವಿಸ್ ಕ್ಯಾಟಲಾಗ್ ಜೀವನಚಕ್ರದ ಘಟನೆಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಈ ಕೆಳಗಿನ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ gRPC ಅಥವಾ REST API ಅನ್ನು ಬಹಿರಂಗಪಡಿಸಬೇಕು:

• PUT /config/{namespace}/{service_id}/{key} — ಪ್ರೊವಿಷನಿಂಗ್ ಸಮಯದಲ್ಲಿ ಕಾನ್ಫಿಗರೇಷನ್ ಮೌಲ್ಯವನ್ನು ಬರೆಯುತ್ತದೆ, ಸ್ವಯಂಚಾಲಿತ Redis ಕ್ಯಾಶ್ ಇನ್‌ವ್ಯಾಲಿಡೇಷನ್‌ನೊಂದಿಗೆ.
• GET /config/{namespace}/{service_id}/{key} — ಕಾನ್ಫಿಗರೇಷನ್ ಮೌಲ್ಯವನ್ನು ಓದುತ್ತದೆ, Redis ಕ್ಯಾಶ್‌ನಿಂದ PostgreSQL ಫಾಲ್‌ಬ್ಯಾಕ್‌ನೊಂದಿಗೆ ಒದಗಿಸಲಾಗುತ್ತದೆ.
• DELETE /config/{namespace}/{service_id} — ಡಿಕಮಿಷನ್ ಮಾಡಿದ ಸರ್ವಿಸ್‌ನ ಎಲ್ಲಾ ಕಾನ್ಫಿಗರೇಷನ್ ಅನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ; ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತವನ್ನು ರೋಲ್‌ಬ್ಯಾಕ್ ಮಾಡಿದಾಗ ಪ್ರಚೋದಿಸಲ್ಪಡುತ್ತದೆ.
• LIST /config/{namespace} — ತಂಡದ ನೇಮ್‌ಸ್ಪೇಸ್‌ನೊಳಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಎಲ್ಲಾ ಸರ್ವಿಸ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ; ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಹೆಲ್ತ್ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನ ಸರ್ವಿಸ್ ಇನ್ವೆಂಟರಿ ವೀಕ್ಷಣೆಗೆ ಶಕ್ತಿ ನೀಡುತ್ತದೆ.

AI-ನಿರ್ದಿಷ್ಟ ಗೋಲ್ಡನ್ ಪಾತ್‌ಗಳಿಗಾಗಿ ವಿನ್ಯಾಸ ತತ್ವಗಳು

AI ವರ್ಕ್‌ಫ್ಲೋಗಳಿಗಾಗಿ ಗೋಲ್ಡನ್ ಪಾತ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಾಂಪ್ರದಾಯಿಕ ಮೈಕ್ರೋಸರ್ವಿಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ ಉದ್ಭವಿಸದ ವಿಷಯಗಳ ಕಡೆಗೆ ಗಮನ ಬೇಕು:

1. GPU ಜೀವನಚಕ್ರ ನಿರ್ವಹಣೆಯನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡಿ — GPU ವರ್ಕ್‌ಲೋಡ್‌ಗಳನ್ನು ಪ್ರೊವಿಷನ್ ಮಾಡುವ ಪ್ರತಿಯೊಂದು ಗೋಲ್ಡನ್ ಪಾತ್ ಕೋಟಾ ಪರಿಶೀಲನೆ, ನೋಡ್ ಪೂಲ್ ಆಯ್ಕೆ ಮತ್ತು ಸ್ವಯಂಚಾಲಿತ ಸ್ಕೇಲ್-ಡೌನ್ ನೀತಿಗಳ ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿರಬೇಕು. ಕ್ಯಾಟಲಾಗ್ ಎಂಟ್ರಿಯಲ್ಲಿನ GPURequirement ಮಾಡೆಲ್ ಘೋಷಣೆಯನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ, ಆದರೆ ಪ್ರೊವಿಷನಿಂಗ್ ಆರಂಭಿಸುವ ಮೊದಲು ಗುರಿ ಕ್ಲಸ್ಟರ್ ಸಾಕಷ್ಟು GPU ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆಯೇ ಎಂದು ಗೋಲ್ಡನ್ ಪಾತ್ ಸಹ ಪರಿಶೀಲಿಸಬೇಕು. ಸಾಮರ್ಥ್ಯ ಸಾಕಾಗದಿದ್ದರೆ, ಡಿಪ್ಲಾಯ್‌ಮೆಂಟ್ ಮಧ್ಯದಲ್ಲಿ ವಿಫಲವಾಗುವ ಬದಲು, ಪಾತ್ ಸಾಮರ್ಥ್ಯ ವಿನಂತಿ ವರ್ಕ್‌ಫ್ಲೋಗೆ ಲಿಂಕ್‌ನೊಂದಿಗೆ ಸ್ಪಷ್ಟ ದೋಷವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

2. ಇನ್‌ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್‌ನೊಂದಿಗೆ ಮಾಡೆಲ್ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್‌ಗಳ ಆವೃತ್ತಿ ನಿರ್ವಹಿಸಿ — ಮಾಡೆಲ್ ಸರ್ವಿಂಗ್‌ಗಾಗಿನ ಗೋಲ್ಡನ್ ಪಾತ್‌ಗಳು ಪ್ರೊವಿಷನಿಂಗ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳಲ್ಲಿ ಮಾಡೆಲ್ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ ಆವೃತ್ತಿಯನ್ನು (ಉದಾ., ನಿರ್ದಿಷ್ಟ ರನ್ ID ಹೊಂದಿರುವ MLflow ಮಾಡೆಲ್ URI) ಪಿನ್ ಮಾಡಬೇಕು. ಇದು ಇನ್‌ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್ ಮತ್ತು ಮಾಡೆಲ್ ಆವೃತ್ತಿಗಳನ್ನು ಅಟಾಮಿಕ್ ಆಗಿ ಡಿಪ್ಲಾಯ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ಒಟ್ಟಿಗೆ ರೋಲ್‌ಬ್ಯಾಕ್ ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಕಾನ್ಫಿಗರೇಷನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಸರ್ವಿಸ್‌ನ PostgreSQL ಬ್ಯಾಕೆಂಡ್‌ನಲ್ಲಿ ಮಾಡೆಲ್ ಆವೃತ್ತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವುದರಿಂದ ಯಾವ ಮಾಡೆಲ್ ಆವೃತ್ತಿ ಯಾವ ಇನ್‌ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್‌ನಲ್ಲಿ ಯಾವ ಸಮಯದಲ್ಲಿ ಚಾಲನೆಯಾಗಿತ್ತು ಎಂಬ ಆಡಿಟ್ ಮಾಡಬಹುದಾದ ಇತಿಹಾಸ ಸೃಷ್ಟಿಯಾಗುತ್ತದೆ.

3. ಡೀಫಾಲ್ಟ್ ಆಗಿ ಅಬ್ಸರ್ವೆಬಿಲಿಟಿಯನ್ನು ಸೇರಿಸಿ — ಪ್ರತಿಯೊಂದು ಗೋಲ್ಡನ್ ಪಾತ್ ಡಿಪ್ಲಾಯ್ ಮಾಡಿದ ಸರ್ವಿಸ್‌ಗಳಿಗಾಗಿ Prometheus ಸ್ಕ್ರೇಪ್ ಟಾರ್ಗೆಟ್‌ಗಳು ಮತ್ತು Grafana ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಪ್ರೊವಿಷನ್ ಮಾಡುವ ಮಾನಿಟರಿಂಗ್ ಹಂತವನ್ನು ಒಳಗೊಂಡಿರಬೇಕು. AI ವರ್ಕ್‌ಲೋಡ್‌ಗಳಿಗೆ ರಿಕ್ವೆಸ್ಟ್ ಲೇಟೆನ್ಸಿಯ ಹೊರತಾಗಿ ವಿಶೇಷ ಮೆಟ್ರಿಕ್‌ಗಳು ಬೇಕು—ಟೋಕನ್ ಥ್ರೂಪುಟ್, ಬ್ಯಾಚ್ ಕ್ಯೂ ಡೆಪ್ತ್, GPU ಬಳಕೆಯ ಶೇಕಡಾವಾರು, ಮತ್ತು ಇನ್‌ಫರೆನ್ಸ್ ಡ್ರಿಫ್ಟ್ ಸ್ಕೋರ್‌ಗಳು. ಮಾನಿಟರಿಂಗ್ ಹಂತವು ಕ್ಯಾಟಲಾಗ್‌ನ MONITORING ಸರ್ವಿಸ್ ಪ್ರಕಾರವನ್ನು ಬಳಸಬೇಕು ಮತ್ತು Grafana ಆಪರೇಟರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಂದಿಸುವ ಮೊದಲೇ ನಿರ್ಮಿಸಿದ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್ JSON ಅನ್ನು ಇಂಜೆಕ್ಟ್ ಮಾಡಬೇಕು.

4. ಪ್ರಯೋಗದಿಂದ ಉತ್ಪಾದನೆಗೆ ಬಡ್ತಿಯನ್ನು ಬೆಂಬಲಿಸಿ — ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಆಗಾಗ್ಗೆ ಎಕ್ಸ್‌ಪೆರಿಮೆಂಟ್ ಟ್ರ್ಯಾಕಿಂಗ್ ಪರಿಸರಗಳಲ್ಲಿ ಮಾಡೆಲ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಾರೆ ಮತ್ತು ಪರಿಶೀಲಿಸಲಾದ ಪ್ರಯೋಗವನ್ನು ಉತ್ಪಾದನಾ ಸರ್ವಿಂಗ್ ಡಿಪ್ಲಾಯ್‌ಮೆಂಟ್‌ಗೆ ಬಡ್ತಿ ನೀಡಲು ಸ್ಪಷ್ಟ ಮಾರ್ಗ ಬೇಕಾಗುತ್ತದೆ. ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಿದ ಗೋಲ್ಡನ್ ಪಾತ್ promote ಕ್ರಿಯೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಫೀಚರ್ ಸ್ಟೋರ್‌ನಿಂದ ಪ್ರಯೋಗದ ಮೆಟಾಡೇಟಾವನ್ನು ಓದುತ್ತದೆ, ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಪ್ರಮಾಣಿತ ಕಂಟೇನರ್ ಇಮೇಜ್ ಬಿಲ್ಡರ್ ಬಳಸಿ ಮಾಡೆಲ್ ಅನ್ನು ಪ್ಯಾಕೇಜ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಎಲ್ಲಾ ಉತ್ಪಾದನಾ ಸರ್ವಿಸ್‌ಗಳಿಗೆ ಬಳಸುವ ಅದೇ ArgoCD ಪೈಪ್‌ಲೈನ್ ಮೂಲಕ ಅದನ್ನು ಡಿಪ್ಲಾಯ್ ಮಾಡುತ್ತದೆ. ಇದು ಹೆಚ್ಚಿನ ML ಯೋಜನೆಗಳು ಸ್ಥಗಿತಗೊಳ್ಳಲು ಕಾರಣವಾಗುವ ಪ್ರಯೋಗ ಮತ್ತು ಉತ್ಪಾದನೆಯ ನಡುವಿನ ಅಂತರವನ್ನು ನಿವಾರಿಸುತ್ತದೆ.

ಈ ತತ್ವಗಳು ಗೋಲ್ಡನ್ ಪಾತ್‌ಗಳು ಕೇವಲ Helm ಚಾರ್ಟ್‌ಗಳ ಸುತ್ತಲಿನ ಅನುಕೂಲಕರ ರ್ಯಾಪರ್‌ಗಳಲ್ಲ, ಬದಲಿಗೆ AI ವರ್ಕ್‌ಲೋಡ್‌ಗಳನ್ನು ದೊಡ್ಡ ಪ್ರಮಾಣದಲ್ಲಿ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಚಲಾಯಿಸುವ ಬಗ್ಗೆ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ತಂಡ ಸಂಗ್ರಹಿಸಿದ ಕಾರ್ಯಾಚರಣೆಯ ಜ್ಞಾನವನ್ನು ಎನ್‌ಕೋಡ್ ಮಾಡುತ್ತವೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ. ಪ್ರತಿಯೊಂದು ಪಾತ್ ಅನ್ನು ಸೆಮ್ಯಾಂಟಿಕ್ ವರ್ಷನಿಂಗ್ ಬಳಸಿ ಆವೃತ್ತಿ ಮಾಡಬೇಕು, ArgoCD ಗಮನಿಸುವ Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕು, ಮತ್ತು ಡೆವಲಪರ್ ಪೋರ್ಟಲ್‌ನ ಕ್ಯಾಟಲಾಗ್‌ಗೆ ಪ್ರಕಟಿಸುವ ಮೊದಲು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಸ್ವಂತ CI ಪೈಪ್‌ಲೈನ್ ಮೂಲಕ ಪರೀಕ್ಷಿಸಬೇಕು.

ಕೋಡ್ ವಾಕ್‌ಥ್ರೂ

ServiceCatalogEntry, GoldenPathDefinition, ಮತ್ತು Platform Control Plane ಗಾಗಿನ ಪ್ರಮುಖ ಪರಿಭಾಷೆ ವ್ಯಾಖ್ಯಾನಗಳ ಮೇಲೆ ನಿರ್ಮಿಸಿ, ಈ ಕೆಳಗಿನ ಅನುಷ್ಠಾನ ಈ ರಚನೆಗಳನ್ನು Pydantic ಮಾಡೆಲ್‌ಗಳಾಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡುತ್ತದೆ, ಇವುಗಳನ್ನು ಪ್ರೊವಿಷನಿಂಗ್ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಯಾವುದೇ ಸರ್ವಿಸ್ ಡಿಪ್ಲಾಯ್ ಮಾಡುವ ಮೊದಲು ಪರಿಶೀಲಿಸುತ್ತದೆ.

Code snippetpython
1from pydantic import BaseModel, Field, field_validator
2from enum import Enum
3from typing import Optional
4from datetime import datetime
5
6class ServiceType(str, Enum):
7    MODEL_SERVING = "model-serving"
8    TRAINING_JOB = "training-job"
9    VECTOR_DB = "vector-db"
10    FEATURE_STORE = "feature-store"
11    MONITORING = "monitoring"
12
13class GPURequirement(BaseModel):
14    gpu_type: str
15    min_count: int = Field(ge=0, default=0)
16    max_count: int = Field(ge=0, default=8)
17    memory_gb: int = Field(ge=0, default=40)
18
19class ServiceDependency(BaseModel):
20    service_id: str
21    version_constraint: str
22    optional: bool = False
23
24class ServiceCatalogEntry(BaseModel):
25    service_id: str = Field(min_length=3, max_length=64)
26    name: str
27    service_type: ServiceType
28    version: str = Field(pattern=r"^\d+\.\d+\.\d+$")
29    owner_team: str
30    description: str = Field(min_length=20)
31    gpu_requirements: Optional[GPURequirement] = None
32    dependencies: list[ServiceDependency] = Field(default_factory=list)
33    helm_chart_ref: Optional[str] = None
34    created_at: datetime = Field(default_factory=datetime.utcnow)
35    deprecated: bool = False
36
37    @field_validator("gpu_requirements")
38    @classmethod
39    def gpu_required_for_compute_services(cls, v, info):
40        stype = info.data.get("service_type")
41        gpu_types = {ServiceType.MODEL_SERVING, ServiceType.TRAINING_JOB}
42        if stype in gpu_types and v is None:
43            raise ValueError(f"gpu_requirements mandatory for {stype}")
44        return v

ServiceType ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ನಿಯಂತ್ರಿಸುವ AI ವರ್ಕ್‌ಲೋಡ್ ವರ್ಗಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ, Kubernetes ಲೇಬಲ್ ಸಂಪ್ರದಾಯಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ kebab-case ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುತ್ತದೆ. GPURequirement ಉಪ-ಮಾಡೆಲ್ ಪ್ರತಿಯೊಂದು ಎಂಟ್ರಿಯ ಮೇಲೆ ಸ್ಪಷ್ಟ ಹಾರ್ಡ್‌ವೇರ್ ಘೋಷಣೆಗಳನ್ನು ಒತ್ತಾಯಿಸುತ್ತದೆ. ServiceCatalogEntry ಮೇಲಿನ field_validator GPU ಅವಶ್ಯಕತೆಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವ ಯಾವುದೇ model-serving ಅಥವಾ training-job ಎಂಟ್ರಿಯನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ, ಡಿಪ್ಲಾಯ್ ಸಮಯದ ಬದಲು ಸ್ಕೀಮಾ ಪರಿಶೀಲನೆ ಸಮಯದಲ್ಲಿ ವೆಚ್ಚ ಗವರ್ನೆನ್ಸ್ ಅನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ—ಯೋಜಿತವಲ್ಲದ GPU ಹಂಚಿಕೆಗಳು ಬಜೆಟ್ ಮೀರಲು ಕಾರಣವಾಗುವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗೆ ಇದು ನಿರ್ಣಾಯಕ ನೀತಿ.

ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಪ್ರತಿಯೊಂದು ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತವನ್ನು ಪ್ರೊವಿಷನ್ ಮಾಡಿದಾಗ, ಅದು ಪರಿಣಾಮವಾಗಿ ಬರುವ ಕನೆಕ್ಷನ್ ವಿವರಗಳನ್ನು ಕಾನ್ಫಿಗರೇಷನ್ ಸ್ಟೋರ್‌ಗೆ ಬರೆಯುತ್ತದೆ, ಇದರಿಂದ ಮುಂದಿನ ಹಂತಗಳು ಅವುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಂಡುಹಿಡಿಯಬಹುದು ಮತ್ತು ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ನಿವಾರಣೆಯಾಗುತ್ತವೆ. ಈ ಕೆಳಗಿನ ಹೆಲ್ಪರ್‌ಗಳು ಪರಿಕಲ್ಪನೆಗಳ ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಲಾದ PUT ಮತ್ತು GET ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುತ್ತವೆ:

Code snippetpython
1import httpx
2
3def write_service_config(
4    namespace: str,
5    service_id: str,
6    key: str,
7    value: str,
8    config_api_base: str = "http://platform-config:8080",
9) -> None:
10    """Write a provisioned service's config for downstream golden path steps."""
11    url = f"{config_api_base}/config/{namespace}/{service_id}/{key}"
12    response = httpx.put(url, json={"value": value}, timeout=10.0)
13    response.raise_for_status()
14
15def read_service_config(
16    namespace: str,
17    service_id: str,
18    key: str,
19    config_api_base: str = "http://platform-config:8080",
20) -> str:
21    """Read a predecessor step's config during golden path provisioning."""
22    url = f"{config_api_base}/config/{namespace}/{service_id}/{key}"
23    response = httpx.get(url, timeout=10.0)
24    response.raise_for_status()
25    return response.json()["value"]

ವೆಕ್ಟರ್ ಡೇಟಾಬೇಸ್ ಹಂತ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ write_service_config("team-alpha", "vector-db/qdrant", "connection", connection_string) ಅನ್ನು ಕರೆಯುತ್ತದೆ. ನಂತರ ಮಾಡೆಲ್-ಸರ್ವಿಂಗ್ ಹಂತ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಕಂಡುಹಿಡಿಯಲು read_service_config("team-alpha", "vector-db/qdrant", "connection") ಅನ್ನು ಕರೆಯುತ್ತದೆ—ಇದು ಪರಿಕಲ್ಪನೆಗಳ ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಲಾದ ನೇಮ್‌ಸ್ಪೇಸ್ಡ್ ಕೀ ಪ್ಯಾಟರ್ನ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಮತ್ತು ಗ್ರಾಹಕ ಕೋಡ್ ಬದಲಾವಣೆಗಳಿಲ್ಲದೆ ಸ್ವಯಂಚಾಲಿತ ಕ್ರೆಡೆನ್ಷಿಯಲ್ ರೊಟೇಷನ್ ಅನ್ನು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.

service_type=ServiceType.MODEL_SERVING ಮತ್ತು gpu_requirements=None ನೊಂದಿಗೆ ServiceCatalogEntry ಅನ್ನು ಇನ್‌ಸ್ಟೆನ್ಸಿಯೇಟ್ ಮಾಡಿ ಪರಿಶೀಲಿಸಿ—ವ್ಯಾಲಿಡೇಟರ್ ValueError ಅನ್ನು ಎಸೆಯಬೇಕು, ಇದು ಯಾವುದೇ ಇನ್‌ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್ ಅನ್ನು ಮುಟ್ಟುವ ಮೊದಲು ಕ್ಯಾಟಲಾಗ್ ನೋಂದಣಿ ಸಮಯದಲ್ಲಿ ಗವರ್ನೆನ್ಸ್ ನೀತಿ ಜಾರಿಯಾಗಿದೆ ಎಂಬುದನ್ನು ದೃಢೀಕರಿಸುತ್ತದೆ.

ಶಿಸ್ತಿನ ಅನ್ವಯ

ಮಾಡಬೇಕಾದವು ಮತ್ತು ಮಾಡಬಾರದವು

ಕ್ಯಾಟಲಾಗ್ ಮಾಡೆಲ್, ಗೋಲ್ಡನ್ ಪಾತ್ ಕಾನ್ಫಿಗರೇಷನ್ ಪ್ರಸಾರ, ಮತ್ತು ಮೇಲಿನ ಶಿಸ್ತು-ನಿರ್ದಿಷ್ಟ ಅನ್ವಯವನ್ನು ಪರಿಶೀಲಿಸಿದ ನಂತರ, ಈ ಕೆಳಗಿನ ನಿರ್ದೇಶನಗಳು ಗವರ್ನೆನ್ಸ್ ಮತ್ತು ವೈರಿಂಗ್ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ನಿಮ್ಮ ಸ್ವಂತ ಕ್ಯಾಟಲಾಗ್ ಎಂಟ್ರಿಗಳು ಮತ್ತು ಗೋಲ್ಡನ್ ಪಾತ್‌ಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವಾಗ ನೇರವಾಗಿ ಅನ್ವಯಿಸಬಹುದಾದ ನಿಯಮಗಳಾಗಿ ಸಾರಾಂಶಗೊಳಿಸುತ್ತವೆ.

ಮಾಡಬೇಕಾದವು

1. ಪ್ರತಿಯೊಂದು model-serving ಮತ್ತು training-job ಕ್ಯಾಟಲಾಗ್ ಎಂಟ್ರಿಯ ಮೇಲೆ gpu_requirements ಅನ್ನು ಘೋಷಿಸಿ — gpu_requirements None ಆಗಿದ್ದಾಗ ServiceCatalogEntry ಮೇಲಿನ field_validator ಈ ಸರ್ವಿಸ್ ಪ್ರಕಾರಗಳನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ, ಯಾವುದೇ ಇನ್‌ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್ ಪ್ರೊವಿಷನ್ ಆಗುವ ಮೊದಲು ಸ್ಕೀಮಾ ಪರಿಶೀಲನೆ ಸಮಯದಲ್ಲಿ ವೆಚ್ಚ ಗವರ್ನೆನ್ಸ್ ಅನ್ನು ಜಾರಿಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಯೋಜಿತವಲ್ಲದ GPU ಬಜೆಟ್ ಮೀರುವಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ.
2. ಸ್ಥಿರವಾದ ನೇಮ್‌ಸ್ಪೇಸ್ಡ್ ಕೀ ಪ್ಯಾಟರ್ನ್‌ನೊಂದಿಗೆ (ಉದಾ., "team-alpha" / "vector-db/qdrant" / "connection") write_service_config / read_service_config ಅನ್ನು ಬಳಸಿ — ಇದು ಪ್ರತಿಯೊಂದು ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತಕ್ಕೆ ಸರ್ವಿಸ್‌ಗಳಾದ್ಯಂತ ಕನೆಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡುವ ಬದಲು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಕಂಟ್ರೋಲ್ ಪ್ಲೇನ್‌ನಿಂದ ಹಿಂದಿನ ಹಂತದ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಂಡುಹಿಡಿಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
3. ಕ್ಯಾಟಲಾಗ್ ಎಂಟ್ರಿಗಳನ್ನು semver ಗೆ ನಿರ್ಬಂಧಿಸಲಾದ version ಫೀಲ್ಡ್ (^\d+\.\d+\.\d+$) ಮತ್ತು deprecated ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ ಮಾಡೆಲ್ ಮಾಡಿ — ಎಂಟ್ರಿಗಳನ್ನು ಆವೃತ್ತಿಗೊಳಿಸಿ ಮತ್ತು ಡಿಪ್ರಿಕೇಷನ್-ಅರಿವಿನೊಂದಿಗೆ ಇಡುವುದರಿಂದ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ServiceDependency.version_constraint ಪರಿಶೀಲನೆಗಳನ್ನು ಜಾರಿಗೊಳಿಸಬಹುದು ಮತ್ತು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತಗಳ ಅನುಕ್ರಮವನ್ನು ಮುರಿಯದೆ ತಂಡಗಳಿಗೆ ವಲಸೆ ಮಾರ್ಗ ಸಿಗುತ್ತದೆ.

ಮಾಡಬಾರದವು

1. gpu_requirements ಅನ್ನು ಬಿಟ್ಟುಬಿಟ್ಟು ಆರ್ಕೆಸ್ಟ್ರೇಟರ್ ಡೀಫಾಲ್ಟ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ ಎಂದು ಊಹಿಸಬೇಡಿ — ServiceType.MODEL_SERVING ಮತ್ತು ServiceType.TRAINING_JOB ಗಾಗಿ GPURequirement ಕಡ್ಡಾಯ ಉಪ-ಮಾಡೆಲ್; ಅದನ್ನು ಬಿಟ್ಟುಬಿಡುವುದು ನೋಂದಣಿ ಸಮಯದಲ್ಲಿ ValueError ಅನ್ನು ಎಸೆಯುತ್ತದೆ, ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಡೀಫಾಲ್ಟ್‌ಗಳ ಮೇಲೆ ಮೌನವಾಗಿ ಅವಲಂಬಿತವಾಗುವುದು ಕ್ಯಾಟಲಾಗ್ ನಿವಾರಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಆಡ್-ಹಾಕ್ ಪ್ರೊವಿಷನಿಂಗ್ ಪ್ಯಾಟರ್ನ್ ಆಗಿದೆ.
2. ಗೋಲ್ಡನ್ ಪಾತ್ ಹಂತದ ಕೋಡ್‌ನಲ್ಲಿ ಕನೆಕ್ಷನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಬೇಡಿ — write_service_config / read_service_config ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡುವುದು ಸ್ವಯಂಚಾಲಿತ ಕ್ರೆಡೆನ್ಷಿಯಲ್-ಪ್ರಸಾರ ಒಪ್ಪಂದವನ್ನು ಮುರಿಯುತ್ತದೆ, ಅಂದರೆ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಬದಲಾವಣೆಗಳಿಗೆ (ಕ್ರೆಡೆನ್ಷಿಯಲ್ ರೊಟೇಷನ್‌ಗಳು ಸೇರಿದಂತೆ) ಒಂದೇ ಕಾನ್ಫಿಗ್-ಸ್ಟೋರ್ ಬರವಣಿಗೆಯ ಬದಲು ಪ್ರತಿಯೊಂದು ಬಳಕೆದಾರ ಸರ್ವಿಸ್‌ನಲ್ಲಿ ಹಸ್ತಚಾಲಿತ ನವೀಕರಣಗಳು ಬೇಕಾಗುತ್ತವೆ.
3. ServiceType enum ನ ಹೊರಗಿನ ಆಡ್-ಹಾಕ್ service_type ಸ್ಟ್ರಿಂಗ್ ಅಡಿಯಲ್ಲಿ ಹೊಸ AI ವರ್ಕ್‌ಲೋಡ್ ಅನ್ನು ನೋಂದಾಯಿಸಬೇಡಿ — enum ನ kebab-case ಮೌಲ್ಯಗಳು (model-serving, vector-db, ಇತ್ಯಾದಿ) Kubernetes ಲೇಬಲ್ ಸಂಪ್ರದಾಯಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ ಮತ್ತು ಗವರ್ನೆನ್ಸ್ ವ್ಯಾಲಿಡೇಟರ್ ಹಾಗೂ GPU-ಅವಶ್ಯಕತೆ ಪರಿಶೀಲನೆ ಶಾಖೆಯಾಗುವ ಕೀಗಳಾಗಿವೆ; ಗುರುತಿಸಲಾಗದ ಪ್ರಕಾರ field_validator ಮತ್ತು ಆರ್ಕೆಸ್ಟ್ರೇಟರ್‌ನ ರಿಸೋರ್ಸ್-ಕೋಟಾ ತರ್ಕ ಎರಡನ್ನೂ ಬೈಪಾಸ್ ಮಾಡುತ್ತದೆ.