"ಸ್ಪ್ರೆಡ್ಶೀಟ್ ಅನ್ನು ಫ್ಯಾಕ್ಟರಿ ಕನ್ವೇಯರ್ ಬೆಲ್ಟ್ನಂತೆ ಕೆಲಸ ಮಾಡಲು ಎಂದಾದರೂ ಪ್ರಯತ್ನಿಸಿದ್ದೀರಾ? ಕೆಲವು ಬೇಸಿಗೆಗಳ ಹಿಂದೆ, ಚಂಡಮಾರುತದಲ್ಲಿ ನರಳುವ ಚಿಕ್ಕ ನಾಯಿಯಂತೆ (chihuahua) ಕಿರುಚುವ ಲ್ಯಾಪ್ಟಾಪ್ನಿಂದ ಲಕ್ಷಾಂತರ ಲಾಗ್ ಫೈಲ್ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೆ. ಆಗ ಯಾರೋ ಒಬ್ಬರು, "ನೀವು ಡಾಟಾಬ್ರಿಕ್ಸ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಿದ್ದೀರಾ?" ಎಂದು ಕೇಳಿದರು. ತಕ್ಷಣ ರೆಕಾರ್ಡ್ ಸ್ಕ್ರಾಚ್ ಆದ ಅನುಭವ."
"ಒಂದು ವೇಳೆ "ಸ್ಪಾರ್ಕ್", "ಕ್ಲಸ್ಟರ್ಗಳು" ಮತ್ತು "ಡೆಲ್ಟಾ ಲೇಕ್" ಎಂಬ ಪದಗಳು ನಿಮ್ಮನ್ನು ಬೆಟ್ಟಗಳಿಗೆ ಓಡಿಹೋಗುವಂತೆ ಮಾಡಿದರೆ, ಒಳ್ಳೆಯ ಸುದ್ದಿ ಇದೆ: Databricks ಅನ್ನು ಬಳಸುವುದು ರಾಕೆಟ್ ಹಡಗನ್ನು ಚಲಾಯಿಸುವಂತೆ ಅನಿಸಬೇಕಾಗಿಲ್ಲ. ಇದನ್ನು ಡೇಟಾ ಜನರಿಗಾಗಿ ಹಂಚಿಕೆಯ ಅಡುಗೆಮನೆ ಎಂದು ಭಾವಿಸಿ—ಬಾಣಸಿಗರು (ನೀವು ಮತ್ತು ನಿಮ್ಮ ತಂಡ) ಪದಾರ್ಥಗಳನ್ನು (ಡೇಟಾ) ತರಬಹುದು, ಬರ್ನರ್ಗಳನ್ನು (compute clusters) ಬಳಸಬಹುದು ಮತ್ತು ಊಟವನ್ನು (analytics, ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗಳು, ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿಗಳು) ಬೇಯಿಸಲು ಪಾಕವಿಧಾನಗಳನ್ನು (notebooks) ಅನುಸರಿಸಬಹುದು, ಅದು ನಿಜವಾಗಿಯೂ ವ್ಯವಹಾರಕ್ಕೆ ಆಹಾರವನ್ನು ನೀಡುತ್ತದೆ."
"ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ನಿಮ್ಮ workspace ಅನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ, ನಿಮ್ಮ ಮೊದಲ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, notebook ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಬರೆಯುತ್ತೇವೆ, SQL ನೊಂದಿಗೆ ಪ್ರಶ್ನಿಸುತ್ತೇವೆ, ಫಲಿತಾಂಶಗಳನ್ನು ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳಲ್ಲಿ ಉಳಿಸುತ್ತೇವೆ, ಕಾರ್ಯಗಳನ್ನು (jobs) ನಿಗದಿಪಡಿಸುತ್ತೇವೆ ಮತ್ತು ಎರಡು ಕ್ಲಾಸಿಕ್ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತೇವೆ: ಅನಿರೀಕ್ಷಿತ ಬಿಲ್ಗಳು ಮತ್ತು ನಿಗೂಢವಾದ “ನನ್ನ ಕೆಲಸ ಏಕೆ ವಿಫಲವಾಯಿತು?” ಎಂಬ ರಾತ್ರಿಗಳು. ನಾನು ವಿಷಯಗಳನ್ನು ಮಾನವೀಯವಾಗಿ, ಪ್ರಾಯೋಗಿಕವಾಗಿ ಮತ್ತು ಪ್ರಾಮಾಣಿಕವಾಗಿ ಇರಿಸುತ್ತೇನೆ—ನಾವು ಇಬ್ಬರು ನೆರೆಹೊರೆಯವರು ಬೇಲಿಯ ಮೇಲೆ ಸಲಹೆಗಳನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳುತ್ತಿರುವಂತೆ, ಆದರೆ ಬೇಲಿಯು parquet ಫೈಲ್ಗಳಿಂದ ಮಾಡಲ್ಪಟ್ಟಿದೆ."
"ಡಾಟಾಬ್ರಿಕ್ಸ್ ಎಂದರೇನು, ನಿಜವಾಗಿಯೂ?
ಡಾಟಾಬ್ರಿಕ್ಸ್ ಅನ್ನು ದೊಡ್ಡ ಡೇಟಾ ಮತ್ತು AI ಗಾಗಿ ಒಂದು ಸರ್ವತೋಮುಖ ಸ್ಟುಡಿಯೋ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಇದು Apache Spark ಅನ್ನು ಸ್ನೇಹಪರ ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ ಸುತ್ತುತ್ತದೆ, ಸಹಯೋಗಾತ್ಮಕ notebooks ಅನ್ನು ಸೇರಿಸುತ್ತದೆ, ಡೆಲ್ಟಾ ಲೇಕ್ನೊಂದಿಗೆ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ (ಸೂಪರ್ಪವರ್ಡ್ ಟೇಬಲ್ ಫಾರ್ಮ್ಯಾಟ್), ಮತ್ತು ನಿಮಗೆ ಆಡಳಿತ ಪರಿಕರಗಳನ್ನು ನೀಡುತ್ತದೆ ಆದ್ದರಿಂದ ನೀವು ಡೇಟಾ-ಫಾಸೆಟ್ ಅನ್ನು ರಾತ್ರಿಯಿಡೀ ಆಕಸ್ಮಿಕವಾಗಿ ತೆರೆದಿಡಬೇಡಿ. ನೀವು Python, SQL, Scala ಅಥವಾ R ಅನ್ನು ಬರೆಯಬಹುದು; ಮಿಕ್ಸ್ ಮತ್ತು ಮ್ಯಾಚ್ ಮಾಡಬಹುದು; ಮತ್ತು ನಿಮ್ಮ ತಂಡದ ಸದಸ್ಯರನ್ನು ಪರಸ್ಪರ ತಳ್ಳಾಡದೆ ಒಂದೇ notebooks ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಆಹ್ವಾನಿಸಬಹುದು.
""ನಿಮ್ಮ ಮಾನಸಿಕ ಮಾದರಿ"
- "Workspace: ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ HQ—ಬಳಕೆದಾರರು, notebooks, ರೆಪೊಗಳು, ಕಾರ್ಯಗಳು."
- "Compute: ಕ್ಲಸ್ಟರ್ಗಳು (notebooks ಮತ್ತು ಕಾರ್ಯಗಳಿಗಾಗಿ) ಮತ್ತು SQL Warehouses (BI/SQL ಪ್ರಶ್ನೆಗಳಿಗಾಗಿ)."
- "Storage: ನಿಮ್ಮ ಕ್ಲೌಡ್ ಡೇಟಾ (S3/ADLS/GCS). ಡಾಟಾಬ್ರಿಕ್ಸ್ ನೀವು ಪ್ರಶ್ನಿಸಬಹುದಾದ ಟೇಬಲ್ಗಳೊಂದಿಗೆ ಸ್ನೇಹಪರ ಕ್ಯಾಟಲಾಗ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ."
- "Governance: ಪ್ರವೇಶ ನಿಯಂತ್ರಣಗಳು ಮತ್ತು Unity Catalog ಆದ್ದರಿಂದ ಸರಿಯಾದ ಜನರು ಸರಿಯಾದ ಡೇಟಾವನ್ನು ನೋಡುತ್ತಾರೆ."
- "Pipelines: ಡೇಟಾ ಇಂಜಿನಿಯರಿಂಗ್ಗಾಗಿ ಡೆಲ್ಟಾ ಲೈವ್ ಟೇಬಲ್ಸ್; ವಿಷಯಗಳನ್ನು ನಿಗದಿಪಡಿಸಲು ಕಾರ್ಯಗಳು; ಪ್ರಯೋಗಗಳು ಮತ್ತು ಮಾದರಿಗಳಿಗಾಗಿ MLflow."
ಹಂತ 1: workspace ಅನ್ನು ರಚಿಸಿ ಅಥವಾ ಸೇರಿಕೊಳ್ಳಿ
ನಿಮ್ಮ ಕಂಪನಿಯು ಈಗಾಗಲೇ ಡಾಟಾಬ್ರಿಕ್ಸ್ ಹೊಂದಿದ್ದರೆ, ನಿಮಗೆ ಆಹ್ವಾನ ಸಿಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಪ್ರಾಯೋಗಿಕ ಆವೃತ್ತಿಗೆ ಸೈನ್ ಅಪ್ ಮಾಡಿ (ನಿಮ್ಮ ಆಯ್ಕೆಯ ಕ್ಲೌಡ್) ಮತ್ತು workspace ಅನ್ನು ರಚಿಸಿ. ನೀವು ಕ್ಲೀನ್, ಎಡ-ಸೈಡ್ಬಾರ್ ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ ಇಳಿಯುತ್ತೀರಿ. ಆಯ್ಕೆಗಳನ್ನು ನೋಡಿ ಗಾಬರಿಯಾಗಬೇಡಿ—ನಾವು ಕೇವಲ ಮೂರರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ: Workspace, Compute ಮತ್ತು Data.
""ಹಂತ 2: ನಿಮ್ಮ ಮೊದಲ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ ("ಒಳಗೆ ಇರುವ ಎಂಜಿನ್")
ಕ್ಲಸ್ಟರ್ ಎಂದರೆ ಡಾಟಾಬ್ರಿಕ್ಸ್ ನಿಮಗಾಗಿ ಪ್ರಾರಂಭಿಸುವ ಕ್ಲೌಡ್ ಯಂತ್ರಗಳ ಗುಂಪು ಅಷ್ಟೇ.
"- "Compute → New Cluster ಕ್ಲಿಕ್ ಮಾಡಿ."
- "ಕ್ಲಸ್ಟರ್ ಮೋಡ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ (ಪರೀಕ್ಷೆಗಾಗಿ Single user ಅಥವಾ Shared ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ)."
- "ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಇಡಲು ಸಣ್ಣ instance ಪ್ರಕಾರವನ್ನು ಆಯ್ಕೆಮಾಡಿ."
- "ಸ್ವಯಂ-ಮುಕ್ತಾಯವನ್ನು ಆನ್ ಮಾಡಿ (ಉದಾಹರಣೆಗೆ, 15–30 ನಿಮಿಷಗಳು). ಅದು ಕ್ಲೌಡ್ಗಾಗಿ "ಲೈಟ್ಸ್ ಆಫ್" ಟೈಮರ್ ಆಗಿದೆ."
- "ರಚಿಸಿ. ಒಂದು ಅಥವಾ ಎರಡು ನಿಮಿಷ ಕಾಯಿರಿ; ನೀವು ಹಸಿರು ಬಣ್ಣದ "Running" ಅನ್ನು ನೋಡುತ್ತೀರಿ."
"Pogue ಸಲಹೆ: ನಿಮ್ಮ ಕ್ಲಸ್ಟರ್ಗೆ ಸ್ಪಷ್ಟವಾದ ಹೆಸರನ್ನು ನೀಡಿ ("dev-pogue-15min-autoterm"). ಭವಿಷ್ಯದಲ್ಲಿ ನೀವೇ ನಿಮಗೆ ಧನ್ಯವಾದ ಹೇಳುತ್ತೀರಿ."
"ಹಂತ 3: notebook ಅನ್ನು ತೆರೆಯಿರಿ ("ನಿಮ್ಮ ಕಾರ್ಯಸ್ಥಳ")"
- "Workspace → New → Notebook."
- "ಭಾಷೆಯನ್ನು ಆಯ್ಕೆಮಾಡಿ. Python ಆರಾಮದಾಯಕ ಆರಂಭಿಕ ಹಂತವಾಗಿದೆ; ನೀವು ಇನ್ನೂ ಮ್ಯಾಜಿಕ್ ಕಮಾಂಡ್ಗಳೊಂದಿಗೆ SQL ಅನ್ನು ಚಲಾಯಿಸಬಹುದು."
- "ನಿಮ್ಮ ಚಾಲನೆಯಲ್ಲಿರುವ ಕ್ಲಸ್ಟರ್ಗೆ notebook ಅನ್ನು ಲಗತ್ತಿಸಿ (ಮೇಲ್ಭಾಗದಲ್ಲಿರುವ ಡ್ರಾಪ್ಡೌನ್)."
"ನಿಮ್ಮ ಮೊದಲ ಸೆಲ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ:",
"print("Hello, Databricks!")"
"ನಂತರ Spark ಟೀಸರ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ:",
"spark.range(5).show"
"ಅಭಿನಂದನೆಗಳು, ನೀವು ಐದಕ್ಕೆ ಎಣಿಸಲು ವಿತರಿಸಿದ ಕಂಪ್ಯೂಟಿಂಗ್ ಎಂಜಿನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ್ದೀರಿ. ನೀವು ಅಧಿಕೃತವಾಗಿ ಡೇಟಾ ಮಾಂತ್ರಿಕ."
"ಹಂತ 4: ಡೇಟಾವನ್ನು ತನ್ನಿ ("ಪದಾರ್ಥ ಶೆಲ್ಫ್")
ನೀವು ಫೈಲ್ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬಹುದು, ಆಬ್ಜೆಕ್ಟ್ ಸ್ಟೋರೇಜ್ಗೆ ಸಂಪರ್ಕಿಸಬಹುದು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಟೇಬಲ್ಗಳನ್ನು ಪ್ರಶ್ನಿಸಬಹುದು.
"- "ಸೈಡ್ಬಾರ್ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ. ನೀವು ಕ್ಯಾಟಲಾಗ್ಗಳು ಮತ್ತು ಸ್ಕೀಮಾಗಳು (ಟೇಬಲ್ಗಳಿಗಾಗಿ ಫೋಲ್ಡರ್ಗಳು) ಮತ್ತು ಡೇಟಾವನ್ನು ಸೇರಿಸಲು ಆಯ್ಕೆಗಳನ್ನು ನೋಡುತ್ತೀರಿ."
- "ನೀವು CSV ಹೊಂದಿದ್ದರೆ, ತ್ವರಿತ ಪರೀಕ್ಷೆಗಾಗಿ ಅದನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಿ. ಡಾಟಾಬ್ರಿಕ್ಸ್ ಸ್ಕೀಮಾವನ್ನು ಊಹಿಸಬಹುದು."
"ಕ್ಲೌಡ್ ಸ್ಟೋರೇಜ್ನಲ್ಲಿ CSV ಅನ್ನು ಓದಲು Python ಬಳಸುವುದು:",
"df = spark.read.option("header", True).csv("/mnt/my-bucket/sales.csv")
df.printSchema
""df.limit(10).display"
"ಆ ಡಿಸ್ಪ್ಲೇ ಫಂಕ್ಷನ್ ಡಾಟಾಬ್ರಿಕ್ಸ್ ಮ್ಯಾಜಿಕ್ ಆಗಿದೆ: ಸುಲಭವಾದ ವಿಂಗಡಣೆ, ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಚಾರ್ಟಿಂಗ್ ಅನ್ನು ತ್ವರಿತವಾಗಿ ಮಾಡಬಹುದು."
"ಹಂತ 5: ನಿಮ್ಮ ಫಲಿತಾಂಶಗಳನ್ನು ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳಾಗಿ ಉಳಿಸಿ (ಡೆಲ್ಟಾ ಏಕೆ?)
ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳು ಸೂಪರ್ಪವರ್ಗಳನ್ನು ಹೊಂದಿರುವ ಸ್ಪ್ರೆಡ್ಶೀಟ್ಗಳಂತೆ: ಅವು ವ್ಯವಹಾರ ಖಾತರಿಗಳನ್ನು (“ACID”) ಇರಿಸುತ್ತವೆ, ಆವೃತ್ತಿಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತವೆ ಮತ್ತು ಅಪ್ಡೇಟ್ಗಳು/ಇನ್ಸರ್ಟ್ಗಳು/ವಿಲೀನಗಳನ್ನು ಸಮಂಜಸವಾಗಿಸುತ್ತವೆ.
""df.write.mode("overwrite").format("delta").saveAsTable("analytics.sales_clean")"
"ಈಗ ನೀವು SQL ನೊಂದಿಗೆ ಪ್ರಶ್ನಿಸಬಹುದು:",
"-- %%sql ನೊಂದಿಗೆ ನಿಮ್ಮ ಸೆಲ್ ಅನ್ನು SQL ಗೆ ಬದಲಾಯಿಸಿ
%%sql
SELECT product, SUM(amount) AS total
FROM analytics.sales_clean
GROUP BY product
ORDER BY total DESC
""ಆಡಿಟ್-ಸ್ನೇಹಿ, ಆವೃತ್ತಿಯ ಡೇಟಾವನ್ನು ನೀವು ಬಯಸುತ್ತೀರಾ? ನೀವು ಸಮಯಕ್ಕೆ ಪ್ರಯಾಣಿಸಬಹುದು:",
"%%sql
SELECT * FROM analytics.sales_clean VERSION AS OF 2
""ಹಂತ 6: SQL Warehouses ನೊಂದಿಗೆ ಸ್ನೇಹ ಬೆಳೆಸಿ (BI ಜನರಿಗಾಗಿ)
ನೀವು ಹೆಚ್ಚಾಗಿ ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗಳು ಮತ್ತು ವ್ಯಾಪಾರ ಪ್ರಶ್ನೆಗಳನ್ನು ಮಾಡುತ್ತಿದ್ದರೆ, SQL Warehouse ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ (Compute → SQL Warehouses). ಇದು SQL ಗಾಗಿ ಟ್ಯೂನ್ ಮಾಡಲಾದ ಲೈಟರ್-ವೈಟ್ ಎಂಜಿನ್ನಂತಿದೆ.
"- "ನಿಮ್ಮ BI ಟೂಲ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಿ (Power BI, Tableau, ಅಥವಾ Databricks SQL Dashboard)."
- "ಡ್ಯಾಶ್ಬೋರ್ಡ್ ರಚಿಸಿ: ದೃಶ್ಯೀಕರಣಗಳು, ಫಿಲ್ಟರ್ಗಳು, ರಿಫ್ರೆಶ್ ವೇಳಾಪಟ್ಟಿಗಳು."
ಹಂತ 7: ಡೆಲ್ಟಾ ಲೈವ್ ಟೇಬಲ್ಗಳೊಂದಿಗೆ ಪೈಪ್ಲೈನ್ಗಳು (“ಕೈಪಿಡಿ” ಯಿಂದ “ಸ್ವಯಂಚಾಲಿತ” ಗೆ)
ನೀವು ಪುನರಾವರ್ತಿತ ರೂಪಾಂತರಗಳನ್ನು ಹೊಂದಿದ್ದರೆ—“ಕಚ್ಚಾ ಮಾರಾಟವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಿ, ಉತ್ಪನ್ನ ಮೆಟಾಡೇಟಾವನ್ನು ಸೇರಿಸಿ, ವಾರದ ಪ್ರಕಾರ ಒಟ್ಟುಗೂಡಿಸಿ”—ಡೆಲ್ಟಾ ಲೈವ್ ಟೇಬಲ್ಸ್ (DLT) ಅದನ್ನು ತಪಾಸಣೆ ಮತ್ತು ವಂಶಾವಳಿಯೊಂದಿಗೆ ನಿರ್ವಹಿಸಲಾದ ಪೈಪ್ಲೈನ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
""ಸಣ್ಣ SQL DLT ಉದಾಹರಣೆ:",
"CREATE OR REFRESH LIVE TABLE sales_clean AS
SELECT * FROM cloud_files('/mnt/data/sales_raw', 'csv');
""CREATE OR REFRESH LIVE TABLE weekly_sales AS
SELECT product, weekofyear(date) AS week,
SUM(amount) AS weekly_total
FROM LIVE.sales_clean
GROUP BY product, week;
"- "DLT ಮಾನಿಟರಿಂಗ್, ಮರುಪ್ರಯತ್ನಗಳು ಮತ್ತು ಡೇಟಾ ಗುಣಮಟ್ಟದ ನಿಯಮಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ."
- "ನಿರೀಕ್ಷೆಗಳನ್ನು ಸೇರಿಸಿ (“amount >= 0” ನಂತಹದ್ದು) ಆದ್ದರಿಂದ ಕೆಟ್ಟ ಡೇಟಾ ನಿಮ್ಮ ತ್ರೈಮಾಸಿಕವನ್ನು ಸದ್ದಿಲ್ಲದೆ ಹಾಳುಮಾಡುವ ಬದಲು ಜೋರಾಗಿ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ."
"ಹಂತ 8: ಕಾರ್ಯಗಳೊಂದಿಗೆ ಅದನ್ನು ನಿಗದಿಪಡಿಸಿ (ಏಕೆಂದರೆ ನಿಮಗೆ ನಿದ್ರೆ ಇಷ್ಟ)"
- "ನಿಮ್ಮ notebook ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ, ವೇಳಾಪಟ್ಟಿಯನ್ನು ಹೊಂದಿಸಿ (ಉದಾಹರಣೆಗೆ, ಪ್ರತಿದಿನ ಬೆಳಿಗ್ಗೆ 2 ಗಂಟೆಗೆ), ಸಣ್ಣ ಜಾಬ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ."
- "ವಿಫಲತೆಗಳಿಗಾಗಿ ಇಮೇಲ್ ಅಥವಾ ಸ್ಲಾಕ್ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಸೇರಿಸಿ."
"ಬೋನಸ್: ಪ್ಯಾರಾಮೀಟರೈಸ್ notebooks ಆದ್ದರಿಂದ ಒಂದೇ ಕೋಡ್ ವಿಭಿನ್ನ ಇನ್ಪುಟ್ಗಳೊಂದಿಗೆ dev/test/prod ಗಾಗಿ ರನ್ ಆಗುತ್ತದೆ."
"ಹಂತ 9: ಅನುಮತಿಗಳು ಮತ್ತು ಆಡಳಿತವು ಕಣ್ಣೀರನ್ನು ತರಿಸುವುದಿಲ್ಲ
ಡೇಟಾ ಪ್ರವೇಶ ನಿಯಂತ್ರಣ ಮುಖ್ಯವಾಗಿದೆ. ಸರಿಯಾದ ಓದುಗರು, ಬರಹಗಾರರು ಮತ್ತು ಮಾಲೀಕರನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಅಂತರ್ನಿರ್ಮಿತ ಕ್ಯಾಟಲಾಗ್ ಅನುಮತಿಗಳನ್ನು ಬಳಸಿ. ನಿಮ್ಮ ಸಂಸ್ಥೆಯು ಕೇಂದ್ರೀಕೃತ ಮೆಟಾಸ್ಟೋರ್ ಅನ್ನು ಬಳಸಿದರೆ, ನೀವು Unity Catalog ಅನ್ನು ಎದುರಿಸುತ್ತೀರಿ: ಇದು catalog.schema.table ನಂತಹ ಹೆಸರುಗಳನ್ನು ಪ್ರಮಾಣೀಕರಿಸುತ್ತದೆ ಮತ್ತು ನಿಮಗೆ ಉತ್ತಮ ಆಡಿಟ್ಗಳು ಮತ್ತು ಉತ್ತಮವಾದ ನಿಯಂತ್ರಣಗಳನ್ನು ನೀಡುತ್ತದೆ.
""Pogue ಸಲಹೆ: ಸರಳವಾಗಿ ಪ್ರಾರಂಭಿಸಿ—ಅನಾಲಿಟಿಕ್ಸ್ಗಾಗಿ ಒಂದು ಕ್ಯಾಟಲಾಗ್, ಸ್ಯಾಂಡ್ಬಾಕ್ಸ್ಗಾಗಿ ಒಂದು—ಮತ್ತು ವಿಷಯಗಳಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಹೆಸರಿಸಿ. ಭವಿಷ್ಯದ ವಿಶ್ಲೇಷಕರು ನಿಮಗೆ ಕಾಫಿ ಕೊಡಿಸುತ್ತಾರೆ."
"ಹಂತ 10: ವೆಚ್ಚ ನಿಯಂತ್ರಣ ("ಅನಿರೀಕ್ಷಿತ ಬಿಲ್ ಪಡೆಯಬೇಡಿ" ವಿಭಾಗ)"
- "ಅನ್ವೇಷಿಸುವಾಗ ಸಣ್ಣ instance ಗಳನ್ನು ಡೀಫಾಲ್ಟ್ ಆಗಿ ಬಳಸಿ."
- "dev ಕ್ಲಸ್ಟರ್ಗಳಲ್ಲಿ ಯಾವಾಗಲೂ ಸ್ವಯಂ-ಮುಕ್ತಾಯವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ."
- "ನಿಗದಿತ ಕಾರ್ಯಗಳಿಗಾಗಿ ಜಾಬ್ ಕ್ಲಸ್ಟರ್ಗಳನ್ನು ಬಳಸಿ (ಪ್ರಾರಂಭಿಸಿ, ರನ್ ಮಾಡಿ, ಸ್ಥಗಿತಗೊಳಿಸಿ)."
- "ಸ್ಮಾರ್ಟ್ ಆಗಿ ಸಂಗ್ರಹಿಸಿ: ನೀವು ಅವುಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಬೇಕಾಗಿಲ್ಲದಿದ್ದರೆ ದೊಡ್ಡ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಉಳಿಸಬೇಡಿ."
- "UI ನ ವೆಚ್ಚದ ಮೆಟ್ರಿಕ್ಗಳನ್ನು ವೀಕ್ಷಿಸಿ ಮತ್ತು ನಿಮ್ಮ ಕ್ಲೌಡ್ ಪೂರೈಕೆದಾರರಲ್ಲಿ ಬಜೆಟ್ಗಳು/ಎಚ್ಚರಿಕೆಗಳನ್ನು ಹೊಂದಿಸಿ."
ದಿನನಿತ್ಯದ ಜೀವನ: ತ್ವರಿತ ಡೆಮೊ
ನಿಮ್ಮ ಬಾಸ್ ಹೀಗೆ ಕೇಳುತ್ತಾರೆ ಎಂದು ಹೇಳೋಣ: "ಈ ತ್ರೈಮಾಸಿಕದಲ್ಲಿ ಯಾವ ಉತ್ಪನ್ನ ಸಾಲುಗಳು ವೇಗವಾಗಿ ಬೆಳೆದವು?" ಇಲ್ಲಿ ಡಾಟಾಬ್ರಿಕ್ಸ್ ಫ್ಲೋ ಇದೆ:
"- "notebook ರಚಿಸಿ, dev ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಲಗತ್ತಿಸಿ."
- "ಮಾರಾಟ ಮತ್ತು ಉತ್ಪನ್ನ ಮೆಟಾಡೇಟಾವನ್ನು (ಕ್ಲೌಡ್ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ CSV) ತೆಗೆದುಕೊಳ್ಳಿ."
- "ಸ್ವಚ್ಛಗೊಳಿಸಿ: ಸ್ಕೀಮಾಗಳನ್ನು ಜಾರಿಗೊಳಿಸಿ, ನಲ್ಗಳನ್ನು ಬಿಡಿ, ದಿನಾಂಕ ಸ್ವರೂಪಗಳನ್ನು ಸರಿಪಡಿಸಿ."
- "ಸ್ವಚ್ಛವಾದ ಡೇಟಾವನ್ನು ಡೆಲ್ಟಾಗೆ ಬರೆಯಿರಿ."
- "ತ್ರೈಮಾಸಿಕದಿಂದ ತ್ರೈಮಾಸಿಕದ ಬೆಳವಣಿಗೆಯನ್ನು ಲೆಕ್ಕಹಾಕಲು SQL ಬಳಸಿ."
- "notebook ನಲ್ಲಿ ದೃಶ್ಯೀಕರಿಸಿ; ನಂತರ ಬಾಸ್ಗಾಗಿ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಅನ್ನು ಪ್ರಕಟಿಸಿ."
- "ಪ್ರತಿದಿನ ಬೆಳಿಗ್ಗೆ ರಿಫ್ರೆಶ್ ಮಾಡಲು notebook ಅನ್ನು ಜಾಬ್ನಲ್ಲಿ ಸುತ್ತಿ."
"ತೊಂದರೆ ನಿವಾರಣೆ ಮೂಲೆ (ಏಕೆಂದರೆ ಇದು ಸಂಭವಿಸುತ್ತದೆ)"
- "ಕ್ಲಸ್ಟರ್ ಪ್ರಾರಂಭವಾಗುವುದಿಲ್ಲ: ನಿಮ್ಮ ಕೋಟಾ/instance ಪ್ರಕಾರವನ್ನು ಪರಿಶೀಲಿಸಿ; ಸಣ್ಣ VM ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ; ಅನುಮತಿಗಳನ್ನು ದೃಢೀಕರಿಸಿ."
- "ಡೇಟಾ ಓದುವುದಿಲ್ಲ: ಮಾರ್ಗ ಮತ್ತು ರುಜುವಾತುಗಳನ್ನು ಪರಿಶೀಲಿಸಿ; ಸಣ್ಣ ಮಾದರಿಯನ್ನು ಪ್ರಯತ್ನಿಸಿ; ಊಹಿಸಲಾದ ಸ್ಕೀಮಾವನ್ನು ಪರಿಶೀಲಿಸಿ."
- "ಕೆಲಸವು ವಿಫಲಗೊಳ್ಳುತ್ತಲೇ ಇರುತ್ತದೆ: ಲಾಗಿಂಗ್ (ಪ್ರಿಂಟ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳು, ಡಿಸ್ಪ್ಲೇ) ಸೇರಿಸಿ, ಸಮಾನಾಂತರತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಮತ್ತು ಇನ್ಪುಟ್ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ."
- "ಫಲಿತಾಂಶಗಳು "ತಪ್ಪಾಗಿ" ಕಾಣುತ್ತವೆ: ಸಮಯ ವಲಯಗಳು! ಅವು ಕುತಂತ್ರವಾಗಿವೆ. ಟೈಮ್ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಎರಕಹೊಯ್ಯಿರಿ, ಡೀಫಾಲ್ಟ್ ಸಮಯ ವಲಯವನ್ನು ಹೊಂದಿಸಿ ಮತ್ತು ಊಹೆಗಳನ್ನು ದಾಖಲಿಸಿ."
"ಸಹಯೋಗ: ಏಕವ್ಯಕ್ತಿ ಪ್ರದರ್ಶನದಂತೆ ಅಲ್ಲ, ಬ್ಯಾಂಡ್ನಂತೆ ಕೆಲಸ ಮಾಡಿ"
- "Git ನೊಂದಿಗೆ notebooks ಅನ್ನು ಸಿಂಕ್ ಮಾಡಲು ರೆಪೊಗಳನ್ನು ಬಳಸಿ. ಬೇಗ ಕಮಿಟ್ ಮಾಡಿ, ಆಗಾಗ್ಗೆ ಕಮಿಟ್ ಮಾಡಿ."
- "notebook ಸೆಲ್ಗಳಲ್ಲಿಯೇ ಕಾಮೆಂಟ್ ಮಾಡಿ. ಸೂಚನೆಗಳೊಂದಿಗೆ ಮೇಲ್ಭಾಗದಲ್ಲಿ "ಮೊದಲು ನನ್ನನ್ನು ಓದಿ" ಸೆಲ್ ಅನ್ನು ಇರಿಸಿ."
- "ಸಣ್ಣ, ಸಂಯೋಜಿಸಬಹುದಾದ notebooks (ತೆಗೆದುಕೊಳ್ಳಿ, ರೂಪಾಂತರಿಸಿ, ವಿಶ್ಲೇಷಿಸಿ) ಮಾಡಿ ಇದರಿಂದ ತಂಡದ ಸದಸ್ಯರು ಮುಳುಗದೆಯೇ ಒಳಗೆ ಹೋಗಬಹುದು."
Python? SQL? ಎರಡೂ.
ನೀವು ಒಂದು notebook ನಲ್ಲಿ ಭಾಷೆಗಳನ್ನು ಮಿಶ್ರಣ ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, SQL ನಲ್ಲಿ ನಿಮ್ಮ ತರ್ಕವನ್ನು ಮೂಲಮಾದರಿಯಾಗಿ ಮಾಡಿ (ವೇಗದ ಪುನರಾವರ್ತನೆ), ನಂತರ ವಿಶೇಷ ಲೈಬ್ರರಿಗಳಿಗಾಗಿ Python ಗೆ ಬದಲಿಸಿ (ಮುನ್ಸೂಚನೆ, NLP). UDF ಗಳನ್ನು ಮಿತವಾಗಿ ಬಳಸಿ—ಸ್ಥಳೀಯ Spark ಕಾರ್ಯಗಳು ವೇಗವಾಗಿರುತ್ತವೆ ಮತ್ತು ಸ್ಕೇಲ್ ಮಾಡಲು ಸ್ನೇಹಿಯಾಗಿರುತ್ತವೆ.
""ಕಾರ್ಯಕ್ಷಮತೆ: ಮೂರು ಲಿವರ್ಗಳು"
- "ವಿಭಾಗಗಳು: ಹುಲ್ಲಿನ ಬಣವೆಯನ್ನು ಬಿಟ್ಟುಬಿಡಿ, ಸೂಜಿಗಳನ್ನು ಮಾತ್ರ ಓದಿ. ಆಗಾಗ್ಗೆ ಫಿಲ್ಟರ್ ಮಾಡಿದ ಕಾಲಮ್ಗಳಿಂದ ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳನ್ನು ವಿಭಾಗಿಸಿ (ದಿನಾಂಕ, ಪ್ರದೇಶ)."
- "ಫೈಲ್ ಗಾತ್ರಗಳು: ಸಣ್ಣ ಫೈಲ್ಗಳು ಮಿನುಗುವಂತೆ ಇವೆ—ಎಲ್ಲೆಡೆ ಮತ್ತು ಕಿರಿಕಿರಿ. ಸಣ್ಣ ಫೈಲ್ಗಳನ್ನು ದಪ್ಪ, ಸಮರ್ಥ ಫೈಲ್ಗಳಾಗಿ ಒಟ್ಟುಗೂಡಿಸಲು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ಬರವಣಿಗೆಗಳು/ಸ್ವಯಂ-ಆಪ್ಟಿಮೈಸ್ ಅನ್ನು ಬಳಸಿ."
- "ಕ್ಯಾಶಿಂಗ್ ಮತ್ತು ಪ್ರಸಾರ ಸೇರ್ಪಡೆಗಳು: ಮರುಬಳಕೆಯ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ; ದೊಡ್ಡ ಸೇರ್ಪಡೆಗಳಲ್ಲಿ ಸಣ್ಣ ಟೇಬಲ್ ಅನ್ನು ಪ್ರಸಾರ ಮಾಡಿ ಇದರಿಂದ ಬದಲಾವಣೆಗಳನ್ನು ತಪ್ಪಿಸಬಹುದು."
"ಎರಡನೇ ದಿನದಲ್ಲಿ ನೀವು ಬಯಸುವ ಭದ್ರತಾ ಮೂಲಭೂತ ಅಂಶಗಳು"
- "ನಿರ್ವಹಿಸಲಾದ ರಹಸ್ಯ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ರಹಸ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ; ಕೀಗಳನ್ನು ಎಂದಿಗೂ ಹಾರ್ಡ್-ಕೋಡ್ ಮಾಡಬೇಡಿ."
- "ಕನಿಷ್ಠ ಸವಲತ್ತು ಅನುದಾನಗಳೊಂದಿಗೆ ಉತ್ಪಾದನಾ ಟೇಬಲ್ಗಳನ್ನು ಲಾಕ್ ಮಾಡಿ."
- "ಯಾರು ಏನು ಬದಲಾಯಿಸಿದರು, ಯಾವಾಗ ಎಂದು ನೋಡಲು ಆಡಿಟ್ ಲಾಗ್ಗಳನ್ನು ಬಳಸಿ."
"ಟಿಂಕರಿಂಗ್ನಿಂದ ಉತ್ಪಾದನೆಯವರೆಗೆ: ವಾಸ್ತವಿಕ ಮಾರ್ಗ"
- "ವಾರ 1: notebooks ಮತ್ತು ಸಣ್ಣ ಕ್ಲಸ್ಟರ್ನೊಂದಿಗೆ ಅನ್ವೇಷಿಸಿ. ಮೊದಲ ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳನ್ನು ಉಳಿಸಿ. ಗೆಲುವುಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಿ."
- "ವಾರ 2: ನಿಮ್ಮ ಮರುಕಳಿಸುವ ರೂಪಾಂತರಗಳಿಗಾಗಿ DLT ಪೈಪ್ಲೈನ್ ಅನ್ನು ನಿರ್ಮಿಸಿ. ಡೇಟಾ ಗುಣಮಟ್ಟದ ತಪಾಸಣೆಗಳನ್ನು ಸೇರಿಸಿ."
- "ವಾರ 3: notebooks ಅನ್ನು ಜಾಬ್ಗಳಾಗಿ ಸುತ್ತಿ, ಎಚ್ಚರಿಕೆಗಳನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗಳನ್ನು SQL Warehouse ಗೆ ಸಂಪರ್ಕಿಸಿ."
- "ವಾರ 4: ರಹಸ್ಯಗಳನ್ನು ವಾಲ್ಟ್ಗೆ ಸರಿಸಿ, ಅನುಮತಿಗಳನ್ನು ಸರಿಪಡಿಸಿ, ಹೆಸರಿಸುವ ಸಂಪ್ರದಾಯಗಳನ್ನು ಹೊಂದಿಸಿ ಮತ್ತು ಎಲ್ಲವನ್ನೂ ದಾಖಲಿಸಿ."
"ಸಾಮಾನ್ಯ ಪುರಾಣಗಳು, ಸೌಮ್ಯವಾಗಿ ಕಡಿಮೆಗೊಳಿಸಲಾಗಿದೆ"
- "ಡಾಟಾಬ್ರಿಕ್ಸ್ Spark ಪರಿಣಿತರಿಗೆ ಮಾತ್ರ." ಇನ್ನು ಮುಂದೆ ಅಲ್ಲ. SQL Warehouses ಮತ್ತು UI ಸಹಾಯಕರ ಎಂದರೆ ವಿಶ್ಲೇಷಕರು Scala ನ ಸಾಲನ್ನು ಬರೆಯದೆಯೇ ಅಭಿವೃದ್ಧಿ ಹೊಂದಬಹುದು."
- "ಇದು ದುಬಾರಿಯಾಗಲಿದೆ." ನೀವು ವಾರಾಂತ್ಯದಲ್ಲಿ ಕ್ರೀಡಾಂಗಣದ ದೀಪಗಳನ್ನು ಆನ್ ಮಾಡಿದರೆ ಅದು ಆಗಬಹುದು. ಸ್ವಯಂ-ಮುಕ್ತಾಯ ಮತ್ತು ಸಣ್ಣ ಜಾಬ್ ಕ್ಲಸ್ಟರ್ಗಳೊಂದಿಗೆ, ನೀವು ವೆಚ್ಚಗಳನ್ನು ನಾಗರಿಕವಾಗಿ ಇರಿಸಬಹುದು."
- "ಆವೃತ್ತಿಯು ತಲೆನೋವು." ಡೆಲ್ಟಾದ ಸಮಯ ಪ್ರಯಾಣ ಮತ್ತು ಟೇಬಲ್ ಇತಿಹಾಸವು ರೋಲ್ಬ್ಯಾಕ್ ಮತ್ತು ಆಡಿಟ್ಗಳನ್ನು ಉತ್ತೇಜಕವಾಗಿ ಸಾಮಾನ್ಯವಾಗಿಸುತ್ತದೆ."
ಸಹಾಯಕ ಸಹಾಯಕನ ಬಗ್ಗೆ ತ್ವರಿತ ಮಾತು
ನೀವು ಬಾಯ್ಲರ್ಪ್ಲೇಟ್ Spark ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು, ನಿಮ್ಮ ಸ್ವಂತ notebook ಅನ್ನು… ನಿಮಗೇ ವಿವರಿಸಲು ಅಥವಾ ಒರಟು ಫಲಿತಾಂಶವನ್ನು ಅಚ್ಚುಕಟ್ಟಾಗಿ ಸಾರಾಂಶವಾಗಿ ಪರಿವರ್ತಿಸಲು ಸಿಲುಕಿಕೊಂಡರೆ, ಸ್ಮಾರ್ಟ್ ಕೋಪೈಲಟ್ ಗಂಟೆಗಳನ್ನು ಉಳಿಸಬಹುದು. Sider.AI ನಂತಹ ಪರಿಕರಗಳು ನಿಮ್ಮ ಬ್ರೌಸರ್ನಲ್ಲಿ ಸ್ನೇಹಪರ ಚಾಟ್ ಬಾಕ್ಸ್ನಂತೆ ಕುಳಿತುಕೊಳ್ಳಬಹುದು, ಸ್ಟಾರ್ಟರ್ PySpark ಸೆಲ್ ಅನ್ನು ರಚಿಸಲು, ಒಂದು ಅಸಮರ್ಪಕ ಸೇರ್ಪಡೆಯನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಲು ಅಥವಾ ನಿಮ್ಮ ಬಾಸ್ಗಾಗಿ ನಿಮ್ಮ notebook ನ ಔಟ್ಪುಟ್ ಅನ್ನು ಓದಬಲ್ಲ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಪರಿವರ್ತಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಇಲ್ಲಿ ಒಂದು ಟ್ರಿಕ್ ಇದೆ: ನಿರ್ದಿಷ್ಟ, ಆಧಾರವಾಗಿರುವ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಿ ("ಈ ಸ್ಕೀಮಾಕ್ಕಾಗಿ ಅಪ್ಸರ್ಟ್ ಲಾಜಿಕ್ನೊಂದಿಗೆ ಡೆಲ್ಟಾ ಟೇಬಲ್ಗೆ PySpark ವಿಲೀನವನ್ನು ಬರೆಯಿರಿ…") ಮತ್ತು ನಿಮ್ಮ ಸ್ಕೀಮಾದ ಸಣ್ಣ, ಪ್ರತಿನಿಧಿ ಮಾದರಿಯನ್ನು ಅಂಟಿಸಿ ಆದ್ದರಿಂದ ಸಲಹೆಯು ಸ್ಥಳದಲ್ಲಿರುತ್ತದೆ. ನೀವು ಎಲ್ಲವನ್ನೂ ಊಹಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ನೀವಿಬ್ಬರೂ ಹೆಗಲ ಮೇಲೆ ಕೈ ಹಾಕುತ್ತೀರಿ. ""ನಿಮ್ಮ ಮೊದಲ ವಾರ: ಮಿನಿ ಪ್ಲೇಬುಕ್
ದಿನ 1: workspace ಲಾಗಿನ್ ರಚಿಸಿ. ಸ್ವಯಂ-ಮುಕ್ತಾಯದೊಂದಿಗೆ ಸಣ್ಣ dev ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ.
ದಿನ 2: ಸಣ್ಣ CSV ಅನ್ನು ಆಮದು ಮಾಡಿ. ಡಿಸ್ಪ್ಲೇಯೊಂದಿಗೆ ಅನ್ವೇಷಿಸಿ. ಡೆಲ್ಟಾ ಟೇಬಲ್ ಅನ್ನು ಉಳಿಸಿ.
ದಿನ 3: ಸರಳವಾದ notebook ಪೈಪ್ಲೈನ್ ಅನ್ನು ನಿರ್ಮಿಸಿ: ಕಚ್ಚಾ → ಸ್ವಚ್ಛ → ಒಟ್ಟುಗೂಡಿಸಿ. ಕಾಮೆಂಟ್ಗಳನ್ನು ಸೇರಿಸಿ.
ದಿನ 4: ಫಲಿತಾಂಶಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು SQL ಗೆ ಬದಲಿಸಿ. ಸಣ್ಣ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಅನ್ನು ನಿರ್ಮಿಸಿ.
ದಿನ 5: ಪ್ರತಿದಿನ ರಿಫ್ರೆಶ್ ಮಾಡಲು ಜಾಬ್ ಅನ್ನು ರಚಿಸಿ. ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಆಫ್ ಮಾಡಿ, ಸಮಯಕ್ಕೆ ಮನೆಗೆ ಹೋಗಿ.
""ಚೀಟ್ ಶೀಟ್: ನೀವು ನಿಜವಾಗಿಯೂ ಬಳಸುವ ಆಜ್ಞೆಗಳು"
- "CSV/Parquet ಅನ್ನು ಓದಿ: spark.read.option("header", True).csv(path) / spark.read.parquet(path)"
- "ಡೆಲ್ಟಾ ಟೇಬಲ್ ಅನ್ನು ಬರೆಯಿರಿ: df.write.format("delta").mode("append").saveAsTable("catalog.schema.table")"
- "SQL ಸೆಲ್: %%sql ನಂತರ ನಿಮ್ಮ ಪ್ರಶ್ನೆ"
- "SQL ನಲ್ಲಿ ವಿಲೀನ (ಅಪ್ಸರ್ಟ್) ಮಾದರಿ:",
MERGE INTO target t
USING source s
ON t.id = s.id
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *;
"- "Python ನಲ್ಲಿ ಆಟೋಲೋಡರ್ (ಹೆಚ್ಚುತ್ತಿರುವ ಸೇವನೆ):"
df = (spark.readStream
.format("cloudFiles")
.option("cloudFiles.format", "json")
.load("/mnt/raw/events"))
""df.writeStream.format("delta").option("checkpointLocation","/mnt/chk").start("/mnt/delta/events")"
"notebooks ನಿಂದ ಪೈಪ್ಲೈನ್ಗಳಿಗೆ ಯಾವಾಗ ಬದಲಾಯಿಸಬೇಕು"
- "ನೀವು ಪ್ರತಿದಿನ ಒಂದೇ notebook ಅನ್ನು ರನ್ ಮಾಡುತ್ತಿದ್ದರೆ, ಅದನ್ನು ಜಾಬ್ಗೆ ಸರಿಸಿ."
- "ನೀವು ಮೂರು ಅಥವಾ ಹೆಚ್ಚಿನ notebooks ಅನ್ನು ಜೋಡಿಸುತ್ತಿದ್ದರೆ, DLT ಅನ್ನು ಪರಿಗಣಿಸಿ—ಇದು ಅವಲಂಬನೆಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಡೇಟಾ ಗುಣಮಟ್ಟದ ನಿಯಮಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ."
- "ಬಹು ತಂಡಗಳು ಔಟ್ಪುಟ್ಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದ್ದರೆ, ಸ್ಪಷ್ಟ SLAs ನೊಂದಿಗೆ ನಿರ್ವಹಿಸಲಾದ ಕ್ಯಾಟಲಾಗ್ಗೆ ಪ್ರಚಾರ ಮಾಡಿ."
ಒಂದು ಕೊನೆಯ ವಿಷಯ (ಡೇಟಾ ಗುರುತ್ವಾಕರ್ಷಣೆಯ Pogue ನ ನಿಯಮ)
ಡೇಟಾ ಗುರುತ್ವಾಕರ್ಷಣೆಯನ್ನು ಹೊಂದಿದೆ. ಸರಿಸಲು ಇದು ಭಾರವಾಗಿರುತ್ತದೆ ಮತ್ತು ಸುತ್ತಲೂ ಎಸೆಯಲು ದುಬಾರಿಯಾಗಿದೆ. ನೀವು ಕಂಪ್ಯೂಟ್ ಅನ್ನು ಡೇಟಾಗೆ ತಂದಾಗ, ನಿಮ್ಮ ಟೇಬಲ್ಗಳನ್ನು ಅಚ್ಚುಕಟ್ಟಾಗಿ ಇಟ್ಟುಕೊಂಡಾಗ (ಡೆಲ್ಟಾ) ಮತ್ತು ಬೇಸರದ ಬಿಟ್ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಿದಾಗ ಡಾಟಾಬ್ರಿಕ್ಸ್ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಚಿಕ್ಕದಾಗಿ ಪ್ರಾರಂಭಿಸಿ, ಎಲ್ಲವನ್ನೂ ಲೇಬಲ್ ಮಾಡಿ ಮತ್ತು ನಿಮ್ಮ ಕ್ಲೌಡ್ ಬಿಲ್ ಅದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ ಎಂಬಂತೆ ಆ ಸ್ವಯಂ-ಮುಕ್ತಾಯ ಟೈಮರ್ಗಳನ್ನು ಹೊಂದಿಸಿ—ಏಕೆಂದರೆ ಅದು ಅವಲಂಬಿತವಾಗಿದೆ.
""ಪ್ರಮುಖ ಅಂಶಗಳು"
- "ಸಣ್ಣ ಕ್ಲಸ್ಟರ್ ಮತ್ತು ಸ್ವಯಂ-ಮುಕ್ತಾಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ."
- "ಅನ್ವೇಷಿಸಲು notebooks ಅನ್ನು ಬಳಸಿ; ಸ್ವಚ್ಛವಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳಾಗಿ ಉಳಿಸಿ."
- "ಪುನರಾವರ್ತಿತ ರೂಪಾಂತರಗಳಿಗಾಗಿ, DLT ಅನ್ನು ಬಳಸಿ ಮತ್ತು ಕಾರ್ಯಗಳೊಂದಿಗೆ ನಿಗದಿಪಡಿಸಿ."
- "SQL Warehouses ಮತ್ತು ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗಳ ಮೂಲಕ ಒಳನೋಟಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಿ."
- "ಮುಂಚೆಯೇ ಅನುಮತಿಗಳು ಮತ್ತು ರಹಸ್ಯಗಳನ್ನು ಲಾಕ್ ಮಾಡಿ; ನೀವು ಹೋದಂತೆ ದಾಖಲಿಸಿ."
- "ನೀವು ಪುಶ್ ಅಗತ್ಯವಿದ್ದಾಗ ಕೋಪೈಲಟ್ ಮೇಲೆ ಒಲವು ತೋರಿ—ಆದರೆ ನಿಮ್ಮ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ಇರಿಸಿ."
"ನೀವು spark.range(5).show ನೊಂದಿಗೆ ಐದಕ್ಕೆ ಎಣಿಸಲು ಸಾಧ್ಯವಾದರೆ, ನೀವು ಡಾಟಾಬ್ರಿಕ್ಸ್ನಲ್ಲಿ ಉಪಯುಕ್ತವಾದದ್ದನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಮತ್ತು ಒಮ್ಮೆ ನಿಮ್ಮ ರಾತ್ರಿಯ ಕೆಲಸವು ಬೆಳಿಗ್ಗೆ 2 ಗಂಟೆಗೆ ನಿಮಗೆ ಪೇಜ್ ಮಾಡದೆಯೇ ಚಲಿಸಿದರೆ, ನೀವು "ವರ್ತಿಸುವ ಡೇಟಾ" ಎಂದು ಕರೆಯಲ್ಪಡುವ ಅಪರೂಪದ ಮತ್ತು ಸುಂದರವಾದ ಪ್ರದೇಶವನ್ನು ದಾಟಿದ್ದೀರಿ ಎಂದು ನಿಮಗೆ ತಿಳಿಯುತ್ತದೆ."
"FAQ"
"Q1:ಹರಿಕಾರರಾಗಿ ಡಾಟಾಬ್ರಿಕ್ಸ್ ಅನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಲು ವೇಗವಾದ ಮಾರ್ಗ ಯಾವುದು?
ಸಣ್ಣ, ಸ್ವಯಂ-ಮುಕ್ತಾಯ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ರಚಿಸಿ, notebook ಅನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಅನ್ವೇಷಿಸಲು ಡಿಸ್ಪ್ಲೇಯೊಂದಿಗೆ ಸಣ್ಣ CSV ಅನ್ನು ಲೋಡ್ ಮಾಡಿ. ನಿಮ್ಮ ಸ್ವಚ್ಛವಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಡೆಲ್ಟಾ ಟೇಬಲ್ ಆಗಿ ಉಳಿಸಿ ಮತ್ತು ಸರಳವಾದ SQL ಪ್ರಶ್ನೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿ—ಇದು ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಕಳೆದುಹೋಗದೆ ಮೊದಲ ದಿನವೇ ನಿಮಗೆ ನಿಜವಾದ ಗೆಲುವುಗಳನ್ನು ನೀಡುತ್ತದೆ.
""Q2:ನಾನು ನನ್ನ ಪೈಪ್ಲೈನ್ಗಾಗಿ notebooks ಅಥವಾ ಡೆಲ್ಟಾ ಲೈವ್ ಟೇಬಲ್ಗಳನ್ನು ಬಳಸಬೇಕೇ?
ನೀವು ವಿಷಯಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವಾಗ notebooks ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ; ಅವು ಪರಿಶೋಧನೆ ಮತ್ತು ತ್ವರಿತ ಗೆಲುವುಗಳಿಗೆ ಪರಿಪೂರ್ಣವಾಗಿವೆ. ನಿಮ್ಮ ತರ್ಕವು ಸ್ಥಿರಗೊಂಡಾಗ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ರನ್ ಆಗಬೇಕಾದಾಗ, ನಿರ್ವಹಿಸಲಾದ ಅವಲಂಬನೆಗಳು, ಡೇಟಾ ಗುಣಮಟ್ಟದ ತಪಾಸಣೆಗಳು ಮತ್ತು ಸುಲಭವಾದ ಮಾನಿಟರಿಂಗ್ಗಾಗಿ ಡೆಲ್ಟಾ ಲೈವ್ ಟೇಬಲ್ಗಳಿಗೆ ಬದಲಿಸಿ.
""Q3:ಡಾಟಾಬ್ರಿಕ್ಸ್ ವೆಚ್ಚಗಳನ್ನು ನಾನು ಹೇಗೆ ನಿಯಂತ್ರಣದಲ್ಲಿ ಇಟ್ಟುಕೊಳ್ಳುವುದು?
dev ಗಾಗಿ ಸಣ್ಣ instance ಗಳನ್ನು ಬಳಸಿ, ಸ್ವಯಂ-ಮುಕ್ತಾಯವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ ಮತ್ತು ನಿಗದಿತ ರನ್ಗಳಿಗಾಗಿ ಜಾಬ್ ಕ್ಲಸ್ಟರ್ಗಳನ್ನು ಆದ್ಯತೆ ನೀಡಿ. ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ ದೈತ್ಯ ಡೇಟಾಫ್ರೇಮ್ಗಳನ್ನು ಉಳಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ ಮತ್ತು ವೆಚ್ಚದ ಮೆಟ್ರಿಕ್ಗಳು ಮತ್ತು ಕ್ಲೌಡ್ ಬಜೆಟ್ಗಳ ಮೇಲೆ ನಿಗಾ ಇರಿಸಿ ಆದ್ದರಿಂದ ಏನೂ ವಾರಾಂತ್ಯದಲ್ಲಿ ರನ್ ಆಗುವುದಿಲ್ಲ.
""Q4:ಕೋಡ್ ಬರೆಯದವರು ಡಾಟಾಬ್ರಿಕ್ಸ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಬಹುದೇ?
ಹೌದು—SQL Warehouses ಜೊತೆಗೆ ಡ್ಯಾಶ್ಬೋರ್ಡ್ಗಳು ಡಾಟಾಬ್ರಿಕ್ಸ್ ಅನ್ನು ವಿಶ್ಲೇಷಕರಿಗೆ ಸ್ನೇಹಿಯನ್ನಾಗಿಸುತ್ತದೆ. ನೀವು ಸರಳ SQL ಅನ್ನು ಬರೆಯಬಹುದು, ಫಲಿತಾಂಶಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಬಹುದು ಮತ್ತು PySpark ಅನ್ನು ಮುಟ್ಟದೆ ಒಳನೋಟಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದು, ನಂತರ ನಿಮಗೆ ಭಾರವಾದ ಲಿಫ್ಟ್ ರೂಪಾಂತರಗಳು ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಇಂಜಿನಿಯರ್ಗಳನ್ನು ಕರೆತನ್ನಿ.
""Q5:ಡೇಟಾವನ್ನು ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳಾಗಿ ಉಳಿಸುವುದರ ಪ್ರಯೋಜನವೇನು?
ಡೆಲ್ಟಾ ಟೇಬಲ್ಗಳು ನಿಮಗೆ ACID ವಹಿವಾಟುಗಳು, ಆವೃತ್ತಿಯ ಇತಿಹಾಸ (ಸಮಯ ಪ್ರಯಾಣ) ಮತ್ತು ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡುತ್ತವೆ. ಇದರರ್ಥ ಸುರಕ್ಷಿತ ನವೀಕರಣಗಳು, ಏನಾದರೂ ತಪ್ಪಾದಾಗ ಸುಲಭವಾದ ರೋಲ್ಬ್ಯಾಕ್ಗಳು ಮತ್ತು ಅದೇ ಡೇಟಾಗೆ ವೇಗವಾದ ಪ್ರಶ್ನೆಗಳು.
"
