100% found this document useful (1 vote)
184 views

Download Full Azure Data Factory by Example: Practical Implementation for Data Engineers - Second Edition Richard Swinbank PDF All Chapters

Second

Uploaded by

lavenfalbyp9
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (1 vote)
184 views

Download Full Azure Data Factory by Example: Practical Implementation for Data Engineers - Second Edition Richard Swinbank PDF All Chapters

Second

Uploaded by

lavenfalbyp9
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 55

Download the Full Version of textbook for Fast Typing at textbookfull.

com

Azure Data Factory by Example: Practical


Implementation for Data Engineers - Second Edition
Richard Swinbank

https://textbookfull.com/product/azure-data-factory-by-
example-practical-implementation-for-data-engineers-second-
edition-richard-swinbank/

OR CLICK BUTTON

DOWNLOAD NOW

Download More textbook Instantly Today - Get Yours Now at textbookfull.com


Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Azure Data Factory by Example Practical Implementation for


Data Engineers 2nd Edition Richard Swinbank

https://textbookfull.com/product/azure-data-factory-by-example-
practical-implementation-for-data-engineers-2nd-edition-richard-
swinbank/
textboxfull.com

Azure Data Factory Cookbook - Second Edition Dmitry Foshin

https://textbookfull.com/product/azure-data-factory-cookbook-second-
edition-dmitry-foshin/

textboxfull.com

Quick Start Guide to Azure Data Factory Azure Data Lake


Server and Azure Data Warehouse 1st Edition Mark Beckner

https://textbookfull.com/product/quick-start-guide-to-azure-data-
factory-azure-data-lake-server-and-azure-data-warehouse-1st-edition-
mark-beckner/
textboxfull.com

Azure Data Factory Cookbook: Data engineers guide to build


and manage ETL and ELT pipelines with data integration ,
2nd Edition Dmitry Foshin
https://textbookfull.com/product/azure-data-factory-cookbook-data-
engineers-guide-to-build-and-manage-etl-and-elt-pipelines-with-data-
integration-2nd-edition-dmitry-foshin/
textboxfull.com
Azure Storage, Streaming, and Batch Analytics: A guide for
data engineers 1st Edition Richard L. Nuckolls

https://textbookfull.com/product/azure-storage-streaming-and-batch-
analytics-a-guide-for-data-engineers-1st-edition-richard-l-nuckolls/

textboxfull.com

Understanding Azure Data Factory: Operationalizing Big


Data and Advanced Analytics Solutions Sudhir Rawat

https://textbookfull.com/product/understanding-azure-data-factory-
operationalizing-big-data-and-advanced-analytics-solutions-sudhir-
rawat/
textboxfull.com

IBM SPSS by example a practical guide to statistical data


analysis Second Edition Service Des Sociétés Secrètes

https://textbookfull.com/product/ibm-spss-by-example-a-practical-
guide-to-statistical-data-analysis-second-edition-service-des-
societes-secretes/
textboxfull.com

SQL Server Data Automation Through Frameworks: Building


Metadata-Driven Frameworks with T-SQL, SSIS, and Azure
Data Factory Andy Leonard
https://textbookfull.com/product/sql-server-data-automation-through-
frameworks-building-metadata-driven-frameworks-with-t-sql-ssis-and-
azure-data-factory-andy-leonard/
textboxfull.com

Blazor WebAssembly By Example Second Edition --

https://textbookfull.com/product/blazor-webassembly-by-example-second-
edition/

textboxfull.com
Azure Data Factory by
Example
Practical Implementation for Data
Engineers
Second Edition

Richard Swinbank
Azure Data Factory by Example: Practical Implementation for Data Engineers,
Second Edition
Richard Swinbank
Tewkesbury, UK

ISBN-13 (pbk): 979-8-8688-0217-1 ISBN-13 (electronic): 979-8-8688-0218-8


https://doi.org/10.1007/979-8-8688-0218-8

Copyright © 2024 by Richard Swinbank


This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with
every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an
editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not
identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication,
neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or
omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: Smriti Srivastava
Development Editor: Laura Berendson
Coordinating Editor: Jessica Vakili
Cover designed by eStudioCalamar
Cover image by Freepik (www.freepik.com)
Distributed to the book trade worldwide by Apress Media, LLC, 1 New York Plaza, New York, NY 10004,
U.S.A. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.
springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science
+ Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation.
For information on translations, please e-mail [email protected]; for reprint,
paperback, or audio rights, please e-mail [email protected].
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and
licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales
web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to
readers on GitHub (https://github.com/Apress/Azure-Data-Factory-by-Example-Second-Edition). For more
detailed information, please visit https://www.apress.com/gp/services/source-code.
Paper in this product is recyclable
To Catherine, thank you for everything.
Table of Contents
About the Author�����������������������������������������������������������������������������������������������������xv

About the Technical Reviewer�������������������������������������������������������������������������������xvii


Acknowledgments��������������������������������������������������������������������������������������������������xix

Introduction������������������������������������������������������������������������������������������������������������xxi

Chapter 1: Creating an Azure Data Factory Instance������������������������������������������������ 1


Get Started in Azure���������������������������������������������������������������������������������������������������������������������� 2
Create a Free Azure Account��������������������������������������������������������������������������������������������������� 2
Explore the Azure Portal���������������������������������������������������������������������������������������������������������� 3
Create a Resource Group�������������������������������������������������������������������������������������������������������������� 5
Create an Azure Data Factory������������������������������������������������������������������������������������������������������� 9
Explore Azure Data Factory Studio���������������������������������������������������������������������������������������������� 12
Navigation Header Bar����������������������������������������������������������������������������������������������������������� 13
Navigation Sidebar���������������������������������������������������������������������������������������������������������������� 15
Link to a Git Repository��������������������������������������������������������������������������������������������������������������� 16
Create a Git Repository in Azure Repos��������������������������������������������������������������������������������� 16
Link the Data Factory to the Git Repository��������������������������������������������������������������������������� 19
ADF Studio As a Web-Based IDE������������������������������������������������������������������������������������������������� 23
Chapter Review��������������������������������������������������������������������������������������������������������������������������� 25
Key Concepts������������������������������������������������������������������������������������������������������������������������� 26
For SSIS Developers�������������������������������������������������������������������������������������������������������������� 29
Looking Ahead����������������������������������������������������������������������������������������������������������������������� 29

v
Table of Contents

Chapter 2: Your First Pipeline��������������������������������������������������������������������������������� 31


Work with Azure Storage������������������������������������������������������������������������������������������������������������ 31
Create an Azure Storage Account������������������������������������������������������������������������������������������ 31
Explore Azure Storage����������������������������������������������������������������������������������������������������������� 34
Upload Sample Data�������������������������������������������������������������������������������������������������������������� 36
Use the Copy Data Tool��������������������������������������������������������������������������������������������������������������� 38
Explore Your Pipeline������������������������������������������������������������������������������������������������������������������ 42
Linked Services��������������������������������������������������������������������������������������������������������������������� 43
Datasets�������������������������������������������������������������������������������������������������������������������������������� 44
Pipelines�������������������������������������������������������������������������������������������������������������������������������� 46
Activities�������������������������������������������������������������������������������������������������������������������������������� 47
Integration Runtimes������������������������������������������������������������������������������������������������������������� 47
Factory Resources in Git������������������������������������������������������������������������������������������������������� 49
Debug Your Pipeline�������������������������������������������������������������������������������������������������������������������� 51
Run the Pipeline in Debug Mode������������������������������������������������������������������������������������������� 52
Inspect Execution Results����������������������������������������������������������������������������������������������������� 53
Chapter Review��������������������������������������������������������������������������������������������������������������������������� 53
Key Concepts������������������������������������������������������������������������������������������������������������������������� 54
For SSIS Developers�������������������������������������������������������������������������������������������������������������� 55

Chapter 3: The Copy Activity���������������������������������������������������������������������������������� 57


Prepare an Azure SQL Database������������������������������������������������������������������������������������������������� 57
Create the Database�������������������������������������������������������������������������������������������������������������� 58
Create Database Objects������������������������������������������������������������������������������������������������������� 63
Import Structured Data into Azure SQL DB��������������������������������������������������������������������������������� 64
Create the Basic Pipeline������������������������������������������������������������������������������������������������������ 65
Process Multiple Files����������������������������������������������������������������������������������������������������������� 74
Truncate Before Load������������������������������������������������������������������������������������������������������������ 76
Map Source and Sink Schemas�������������������������������������������������������������������������������������������������� 77
Create a New Source Dataset������������������������������������������������������������������������������������������������ 78
Create a New Pipeline����������������������������������������������������������������������������������������������������������� 79
Configure Schema Mapping�������������������������������������������������������������������������������������������������� 80

vi
Table of Contents

Import Semi-structured Data into Azure SQL DB������������������������������������������������������������������������ 82


Create a JSON File Dataset��������������������������������������������������������������������������������������������������� 83
Create the Pipeline���������������������������������������������������������������������������������������������������������������� 83
Configure Schema Mapping�������������������������������������������������������������������������������������������������� 84
Set the Collection Reference������������������������������������������������������������������������������������������������� 86
The Effect of Schema Drift���������������������������������������������������������������������������������������������������� 87
Understanding Type Conversion�������������������������������������������������������������������������������������������� 88
Transform JSON Files into Parquet��������������������������������������������������������������������������������������������� 89
Create a New JSON Dataset�������������������������������������������������������������������������������������������������� 90
Create a Parquet Dataset������������������������������������������������������������������������������������������������������� 90
Create and Run the Transformation Pipeline������������������������������������������������������������������������� 91
Performance Settings����������������������������������������������������������������������������������������������������������������� 92
Data Integration Units������������������������������������������������������������������������������������������������������������ 92
Degree of Copy Parallelism��������������������������������������������������������������������������������������������������� 93
Chapter Review��������������������������������������������������������������������������������������������������������������������������� 94
Key Concepts������������������������������������������������������������������������������������������������������������������������� 94
Azure Data Factory Studio����������������������������������������������������������������������������������������������������� 95
For SSIS Developers�������������������������������������������������������������������������������������������������������������� 97

Chapter 4: Pipeline Expressions����������������������������������������������������������������������������� 99


Explore the Pipeline Expression Builder������������������������������������������������������������������������������������� 99
Use System Variables���������������������������������������������������������������������������������������������������������������� 102
Enable Storage of Audit Information������������������������������������������������������������������������������������ 102
Create a New Pipeline��������������������������������������������������������������������������������������������������������� 102
Add New Source Columns��������������������������������������������������������������������������������������������������� 102
Run the Pipeline������������������������������������������������������������������������������������������������������������������ 104
Access Activity Run Properties������������������������������������������������������������������������������������������������� 106
Create Database Objects����������������������������������������������������������������������������������������������������� 106
Add Stored Procedure Activity��������������������������������������������������������������������������������������������� 107
Run the Pipeline������������������������������������������������������������������������������������������������������������������ 111

vii
Table of Contents

Use the Lookup Activity������������������������������������������������������������������������������������������������������������� 111


Create Database Objects����������������������������������������������������������������������������������������������������� 112
Configure the Lookup Activity���������������������������������������������������������������������������������������������� 113
Use Breakpoints������������������������������������������������������������������������������������������������������������������ 116
Use the Lookup Value���������������������������������������������������������������������������������������������������������� 117
Update the Stored Procedure Activity���������������������������������������������������������������������������������� 118
Run the Pipeline������������������������������������������������������������������������������������������������������������������ 119
User Variables��������������������������������������������������������������������������������������������������������������������������� 120
Create a Variable����������������������������������������������������������������������������������������������������������������� 120
Set a Variable���������������������������������������������������������������������������������������������������������������������� 121
Use the Variable������������������������������������������������������������������������������������������������������������������� 122
Array Variables�������������������������������������������������������������������������������������������������������������������� 124
Concatenate Strings������������������������������������������������������������������������������������������������������������������ 124
Infix Operators��������������������������������������������������������������������������������������������������������������������� 126
String Interpolation�������������������������������������������������������������������������������������������������������������� 126
Escaping @�������������������������������������������������������������������������������������������������������������������������� 126
Chapter Review������������������������������������������������������������������������������������������������������������������������� 127
Key Concepts����������������������������������������������������������������������������������������������������������������������� 127
For SSIS Developers������������������������������������������������������������������������������������������������������������ 129

Chapter 5: Parameters������������������������������������������������������������������������������������������ 131


Set Up an Azure Key Vault��������������������������������������������������������������������������������������������������������� 131
Create a Key Vault��������������������������������������������������������������������������������������������������������������� 132
Grant Access to Key Vault Secrets��������������������������������������������������������������������������������������� 133
Create a Key Vault Secret���������������������������������������������������������������������������������������������������� 136
Create a Key Vault ADF Linked Service�������������������������������������������������������������������������������� 138
Create a New Storage Account Linked Service������������������������������������������������������������������� 139
Use Dataset Parameters����������������������������������������������������������������������������������������������������������� 141
Create a Parameterized Dataset������������������������������������������������������������������������������������������ 143
Use the Parameterized Dataset������������������������������������������������������������������������������������������� 145
Reuse the Parameterized Dataset��������������������������������������������������������������������������������������� 147

viii
Table of Contents

Use Linked Service Parameters������������������������������������������������������������������������������������������������ 147


Create a Parameterized Linked Service������������������������������������������������������������������������������ 148
Increase Dataset Reusability����������������������������������������������������������������������������������������������� 150
Use the New Dataset����������������������������������������������������������������������������������������������������������� 152
Why Parameterize Linked Services?����������������������������������������������������������������������������������� 152
Use Pipeline Parameters����������������������������������������������������������������������������������������������������������� 152
Create a Parameterized Pipeline����������������������������������������������������������������������������������������� 153
Run the Parameterized Pipeline������������������������������������������������������������������������������������������ 154
Use the Execute Pipeline Activity���������������������������������������������������������������������������������������� 156
Parallel Execution���������������������������������������������������������������������������������������������������������������� 158
Use Pipeline Return Values������������������������������������������������������������������������������������������������������� 158
Return a Value from a Pipeline�������������������������������������������������������������������������������������������� 158
Reference Pipeline Return Values��������������������������������������������������������������������������������������� 160
Global Parameters��������������������������������������������������������������������������������������������������������������������� 162
Chapter Review������������������������������������������������������������������������������������������������������������������������� 163
Key Concepts����������������������������������������������������������������������������������������������������������������������� 163
For SSIS Developers������������������������������������������������������������������������������������������������������������ 165

Chapter 6: Controlling Flow���������������������������������������������������������������������������������� 167


Create a Per-File Pipeline���������������������������������������������������������������������������������������������������������� 167
Use Activity Dependency Conditions����������������������������������������������������������������������������������������� 169
Explore Dependency Condition Interactions������������������������������������������������������������������������ 172
Understand Pipeline Outcome��������������������������������������������������������������������������������������������� 177
Raise Errors������������������������������������������������������������������������������������������������������������������������������ 181
Use Conditional Activities���������������������������������������������������������������������������������������������������������� 182
Divert Error Rows���������������������������������������������������������������������������������������������������������������� 183
Load Error Rows������������������������������������������������������������������������������������������������������������������ 186
Understand the Switch Activity������������������������������������������������������������������������������������������� 192
Use Iteration Activities�������������������������������������������������������������������������������������������������������������� 194
Use the Get Metadata Activity��������������������������������������������������������������������������������������������� 194
Use the ForEach Activity������������������������������������������������������������������������������������������������������ 196

ix
Table of Contents

Ensure Parallelizability�������������������������������������������������������������������������������������������������������� 198


Understand the Until Activity����������������������������������������������������������������������������������������������� 201
Chapter Review������������������������������������������������������������������������������������������������������������������������� 203
Key Concepts����������������������������������������������������������������������������������������������������������������������� 203
For SSIS Developers������������������������������������������������������������������������������������������������������������ 205

Chapter 7: Data Flows������������������������������������������������������������������������������������������ 207


Build a Data Flow���������������������������������������������������������������������������������������������������������������������� 207
Enable Data Flow Debugging���������������������������������������������������������������������������������������������� 208
Add a Data Flow Transformation����������������������������������������������������������������������������������������� 210
Use the Filter Transformation���������������������������������������������������������������������������������������������� 214
Use the Lookup Transformation������������������������������������������������������������������������������������������� 217
Use the Derived Column Transformation����������������������������������������������������������������������������� 221
Use the Select Transformation�������������������������������������������������������������������������������������������� 223
Use the Sink Transformation����������������������������������������������������������������������������������������������� 223
Execute the Data Flow��������������������������������������������������������������������������������������������������������� 224
Maintain a Product Dimension�������������������������������������������������������������������������������������������������� 229
Create a Dimension Table���������������������������������������������������������������������������������������������������� 229
Create Supporting Datasets������������������������������������������������������������������������������������������������� 230
Build the Product Maintenance Data Flow�������������������������������������������������������������������������� 230
Execute the Dimension Data Flow��������������������������������������������������������������������������������������� 237
Reuse Data Flow Logic�������������������������������������������������������������������������������������������������������������� 238
Create a User-Defined Function������������������������������������������������������������������������������������������� 238
Create a Data Flow Flowlet�������������������������������������������������������������������������������������������������� 242
Chapter Review������������������������������������������������������������������������������������������������������������������������� 246
Key Concepts����������������������������������������������������������������������������������������������������������������������� 246
For SSIS Developers������������������������������������������������������������������������������������������������������������ 249

Chapter 8: Integration Runtimes�������������������������������������������������������������������������� 251


Inspect the AutoResolveIntegrationRuntime����������������������������������������������������������������������������� 251
Use Custom Azure Integration Runtimes����������������������������������������������������������������������������������� 252
Control the Geography of Data Movement��������������������������������������������������������������������������� 253
Create Secure Network Connections to Data Stores����������������������������������������������������������� 257
x
Table of Contents

Data Flow Cluster Properties����������������������������������������������������������������������������������������������� 266


Self-Hosted Integration Runtime����������������������������������������������������������������������������������������������� 268
Create a Shared Data Factory��������������������������������������������������������������������������������������������� 269
Create a Self-Hosted Integration Runtime��������������������������������������������������������������������������� 269
Link to a Self-Hosted Integration Runtime�������������������������������������������������������������������������� 270
Use the Self-Hosted Integration Runtime���������������������������������������������������������������������������� 272
Azure-SSIS Integration Runtime����������������������������������������������������������������������������������������������� 277
Create an Azure-SSIS Integration Runtime�������������������������������������������������������������������������� 278
Deploy SSIS Packages to the Azure-SSIS IR������������������������������������������������������������������������ 281
Run an SSIS Package in ADF����������������������������������������������������������������������������������������������� 282
Stop the Azure-SSIS IR�������������������������������������������������������������������������������������������������������� 284
Managed Airflow in Azure Data Factory������������������������������������������������������������������������������������ 286
Chapter Review������������������������������������������������������������������������������������������������������������������������� 287
Key Concepts����������������������������������������������������������������������������������������������������������������������� 287
For SSIS Developers������������������������������������������������������������������������������������������������������������ 289

Chapter 9: Power Query in ADF���������������������������������������������������������������������������� 291


Create a Power Query Mashup������������������������������������������������������������������������������������������������� 291
Explore the Power Query Editor������������������������������������������������������������������������������������������������ 293
Wrangle Data���������������������������������������������������������������������������������������������������������������������������� 295
Run the Power Query Activity��������������������������������������������������������������������������������������������������� 299
Chapter Review������������������������������������������������������������������������������������������������������������������������� 301
Key Concepts����������������������������������������������������������������������������������������������������������������������� 301

Chapter 10: Publishing to ADF������������������������������������������������������������������������������ 303


Publish to Your Factory Instance����������������������������������������������������������������������������������������������� 304
Trigger a Pipeline from ADF Studio�������������������������������������������������������������������������������������� 304
Publish Factory Resources�������������������������������������������������������������������������������������������������� 305
Inspect Published Pipeline Run Outcome���������������������������������������������������������������������������� 306
Publish to Another Data Factory����������������������������������������������������������������������������������������������� 307
Prepare a Production Environment�������������������������������������������������������������������������������������� 307
Export an ARM Template from Your Development Factory�������������������������������������������������� 309

xi
Table of Contents

Import an ARM Template into Your Production Factory������������������������������������������������������� 310


Understand Deployment Parameters����������������������������������������������������������������������������������� 313
Automate Publishing to Another Factory���������������������������������������������������������������������������������� 314
Create a DevOps Service Connection���������������������������������������������������������������������������������� 315
Create an Azure DevOps Pipeline���������������������������������������������������������������������������������������� 316
Trigger an Automatic Deployment��������������������������������������������������������������������������������������� 322
Feature Branch Workflow���������������������������������������������������������������������������������������������������������� 324
Azure Data Factory Utilities������������������������������������������������������������������������������������������������� 325
Publish Resources As JSON������������������������������������������������������������������������������������������������ 326
Chapter Review������������������������������������������������������������������������������������������������������������������������� 330

Chapter 11: Triggers��������������������������������������������������������������������������������������������� 333


Time-Based Triggers����������������������������������������������������������������������������������������������������������������� 333
Use a Schedule Trigger�������������������������������������������������������������������������������������������������������� 333
Use a Tumbling Window Trigger������������������������������������������������������������������������������������������� 341
Event-Based Triggers���������������������������������������������������������������������������������������������������������������� 349
Register the Event Grid Resource Provider�������������������������������������������������������������������������� 350
Use a Storage Event Trigger������������������������������������������������������������������������������������������������ 350
Understand Custom Event Triggers������������������������������������������������������������������������������������� 354
Triggering Pipelines from Outside ADF�������������������������������������������������������������������������������������� 357
Managing Triggers in Automated Deployments������������������������������������������������������������������������ 357
Chapter Review������������������������������������������������������������������������������������������������������������������������� 358
Key Concepts����������������������������������������������������������������������������������������������������������������������� 359
For SSIS Developers������������������������������������������������������������������������������������������������������������ 361

Chapter 12: Monitoring����������������������������������������������������������������������������������������� 363


Generate Factory Activity���������������������������������������������������������������������������������������������������������� 363
Inspect Factory Logs����������������������������������������������������������������������������������������������������������������� 364
Inspect Trigger Runs������������������������������������������������������������������������������������������������������������ 364
Inspect Pipeline Runs���������������������������������������������������������������������������������������������������������� 366
Add Metadata to the Log����������������������������������������������������������������������������������������������������� 368
Inspect Factory Metrics������������������������������������������������������������������������������������������������������������ 371

xii
Table of Contents

Export Logs and Metrics����������������������������������������������������������������������������������������������������������� 373


Create a Log Analytics Workspace�������������������������������������������������������������������������������������� 373
Configure Diagnostic Settings��������������������������������������������������������������������������������������������� 373
Inspect Logs in Blob Storage����������������������������������������������������������������������������������������������� 375
Alternative Diagnostic Settings Destinations���������������������������������������������������������������������� 377
Use the Log Analytics Workspace��������������������������������������������������������������������������������������������� 378
Receive Alerts��������������������������������������������������������������������������������������������������������������������������� 380
Configure Metric-Based Alerts�������������������������������������������������������������������������������������������� 380
Configure Log-Based Alerts������������������������������������������������������������������������������������������������� 383
Stop ADF Triggers and Disable Alert Rules�������������������������������������������������������������������������������� 385
Chapter Review������������������������������������������������������������������������������������������������������������������������� 385
Key Concepts����������������������������������������������������������������������������������������������������������������������� 385
For SSIS Developers������������������������������������������������������������������������������������������������������������ 387

Chapter 13: Tools and Other Services������������������������������������������������������������������� 389


Azure Data Factory Tools����������������������������������������������������������������������������������������������������������� 389
Prepare a Source Database������������������������������������������������������������������������������������������������� 390
Metadata-Driven Data Copy������������������������������������������������������������������������������������������������ 391
Change Data Capture����������������������������������������������������������������������������������������������������������� 400
Related Services����������������������������������������������������������������������������������������������������������������������� 407
Azure Synapse Analytics����������������������������������������������������������������������������������������������������� 407
Microsoft Fabric������������������������������������������������������������������������������������������������������������������ 409
Chapter Review������������������������������������������������������������������������������������������������������������������������� 410
Key Concepts����������������������������������������������������������������������������������������������������������������������� 411
For SSIS Developers������������������������������������������������������������������������������������������������������������ 413

Index��������������������������������������������������������������������������������������������������������������������� 415

xiii
About the Author
Richard Swinbank is a data engineer and Microsoft Data
Platform MVP. He specializes in building and automating
analytics platforms using Microsoft technologies from the
SQL Server stack to the Azure cloud. He is a fervent advocate
of DataOps, with a technical focus on bringing automation
to both analytics development and operations. An active
member of the data community and keen knowledge-sharer,
Richard is a volunteer, organizer, speaker, blogger, open
source contributor, and author. He holds a PhD in computer
science from the University of Birmingham, UK.

xv
About the Technical Reviewer
Kasam Shaikh is a prominent figure in India's artificial
intelligence landscape, holding the distinction of being one
of India’s first four Microsoft Most Valuable Professionals
(MVPs) in AI. Currently serving as a Senior Architect at
Capgemini, Kasam boasts an impressive track record as an
author, having authored five best-selling books dedicated to
Azure and AI technologies. Beyond his writing endeavors,
Kasam is recognized as a Microsoft Certified Trainer (MCT)
and influential tech YouTuber (@mekasamshaikh). He
also leads the largest online Azure AI community, known
as DearAzure | Azure INDIA, and is a globally renowned AI speaker. His commitment
to knowledge sharing extends to contributions to Microsoft Learn, where he plays a
pivotal role.
Within the realm of AI, Kasam is a respected subject matter expert (SME) in
generative AI for the cloud, complementing his role as a senior cloud architect. He
actively promotes the adoption of No Code and Azure OpenAI solutions and possesses
a strong foundation in hybrid and cross-cloud practices. Kasam's versatility and
expertise make him an invaluable asset in the rapidly evolving landscape of technology,
contributing significantly to the advancement of Azure and AI.
Kasam was recently awarded as top voice in AI by LinkedIn, making him the sole
exclusive Indian professional acknowledged by both Microsoft and LinkedIn for his
contributions to the world of artificial intelligence.
Kasam Shaikh is a multifaceted professional who excels in both technical expertise
and knowledge dissemination. His contributions span writing, training, community
leadership, public speaking, and architecture, establishing him as a true luminary in the
world of Azure and AI.

xvii
Acknowledgments
While this book is about one specific service – Azure Data Factory – it is the product of
years of experience working as a data engineer. I am enormously grateful to the many
colleagues, past and present, from whom I continue to learn every day. I’m indebted to
the wider Microsoft data platform community, a group of engaged, generous people who
are unstinting in their advice and support for others working in this space.
Innumerable technical conversations with Paul Andrew made the first edition
of this book many times better than it could otherwise have been, and his influence
pervades this updated version. Paul is a real expert in this technology, and I continue to
be fortunate to have benefited from his advice. I’m grateful to Kasam Shaikh, technical
reviewer for this edition, for providing an indispensable second pair of eyes over the text.
Thanks also to the editorial team at Apress – Smriti Srivastava, Nirmal Selvaraj, Mark
Powers, and others, without whom this book would not have been possible.
Finally, to Catherine, whose patient encouragement accompanies my every
endeavor – thank you so very much.

xix
Introduction
Azure Data Factory (ADF) is Microsoft's cloud-based ETL service for scale-out serverless
data movement, integration, and transformation. The earliest version of the service went
into public preview in 2014 and was superseded by version 2 in 2018. After support for
version 1 of ADF was discontinued at the end of August 2023, ADF V2 remains the only
version of the service available – it is on that version that this book is exclusively focused.
From the outset, a major strength of ADF has been its ability to interface with
many types of data source and to orchestrate data movement between them. Data
transformation was at first delegated to external compute services such as HDInsight
and Stream Analytics, but with the introduction of Mapping Data Flows in 2019 (now
simply “Data Flows”), it became possible to implement advanced data transformation
activities natively in ADF.
ADF can interact with 100 or more types of external service. The majority of these
are data storage services – databases, file systems, and so on – but the list of supported
compute environments has also grown over time and now includes Azure Databricks,
Azure Synapse Analytics, and Azure Machine Learning, among others. The object of
this book is not to give you the grand tour of all of these services, each of which has its
own complexities and many of which you may never use. Instead, it focuses on the rich
capabilities that ADF offers to integrate data from these many sources and to transform it
natively.
Services in Microsoft Azure evolve rapidly, with new features emerging with every
month that passes. Inevitably, you will find places in which user experiences – such
as Azure Data Factory Studio or the Azure portal – differ from the screenshots and
descriptions presented here, but the core concepts remain the same. The conceptual
understanding that you gain from this book will enable you confidently to expand your
knowledge of ADF, in step with the evolution of the service.
Since the first edition of this book, pipelines in the style introduced by ADF have
appeared in two newer Microsoft products – first in Azure Synapse Analytics, then in
Microsoft Fabric. Many of the concepts and tools described in this book are transferable
to Synapse, Fabric, or both. At the time of writing, ADF remains the most mature

xxi
Introduction

implementation of data integration pipelines, and a firm background in ADF will provide
you with a solid foundation for pipeline creation in either of the two newer services.
Chapter 13 provides a brief comparison of pipeline implementation in ADF compared to
that in Azure Synapse Analytics or Microsoft Fabric.

About You
The book is designed with the working data engineer in mind. It assumes no prior
knowledge of Azure Data Factory so is suited to both new data engineers and seasoned
professionals new to the ADF service. A basic working knowledge of T-SQL is expected.
If you have a background in SQL Server Integration Services (SSIS), you will find
that ADF contains many familiar concepts. The “For SSIS developers” notes inserted
at various points in the text are to help you to leverage your existing knowledge, or to
indicate where you should be aware of differences from SSIS.

How to Use This Book


The book uses a series of tutorials to get you using ADF right away, introducing and
reinforcing concepts naturally as you encounter them. To undertake exercises, you will
need access to an Azure subscription and a web browser supported by ADF Studio –
browsers supported currently are Microsoft Edge and Google Chrome. Choose a
subscription in which you have sufficient permissions to create and manage the various
Azure resources you will be using. Chapter 1 includes the creation of a free Azure trial
subscription, ensuring that you have the necessary access. A Windows computer is
necessary for certain parts of Chapter 8.
Work through the chapters in order, as later chapters rely on both knowledge
and ADF resources developed in earlier chapters. When directed to give a resource a
specific name, do so, because that name may later be used to refer back to the resource.
References to labels in user interface components, for example, field names or page
titles, are given in italics. Input values, for example, for text box input or radio button
selection, are given in quotes – when you are asked to enter a value given in quotes, do
not include the quote characters unless you are directed to do so.

xxii
CHAPTER 1

Creating an Azure Data


Factory Instance
A major responsibility of the data engineer is the development and management of
extract, transform, and load (ETL) and other data integration workloads. Real-time
integration workloads process data as it is generated – for example, a transaction being
recorded at a point-of-sale terminal or a sensor measuring the temperature in a data
center. In contrast, batch integration workloads run at intervals, usually processing data
produced since the previous batch run.
Azure Data Factory (ADF) is Microsoft’s cloud-native service for managing batch
data integration workloads. ADF is an example of a serverless cloud service – you use it to
create your own ETL applications, but you don’t have to worry about infrastructure like
operating systems or servers or how to manage changes in demand. Access to the service
is achieved by means of a data factory instance (often simply called “a data factory”).
The majority of this book is concerned with the authoring and management of ADF
pipelines – data integration workload units written and executed in an ADF instance.
In order to create pipelines, you need first to have access to an ADF instance. In this
chapter, you will create a new ADF instance, ready to start building pipelines in Chapter 2.
To get started, you will need nothing more than an Internet connection and either the
Microsoft Edge or Google Chrome web browser.

Note You may be using variations on ETL like extract, load, and transform (ELT)
or extract, load, transform, and load (ELTL). ADF can be used in any of these data
integration scenarios, and I use the term “ETL” loosely to describe any of them.

1
© Richard Swinbank 2024
R. Swinbank, Azure Data Factory by Example, https://doi.org/10.1007/979-8-8688-0218-8_1
Chapter 1 Creating an Azure Data Factory Instance

Get Started in Azure


To access cloud services in Microsoft Azure, you need a Microsoft account and an Azure
subscription. My goal is to get you up and running at zero cost – in the following sections,
I step through the creation of a free Azure trial subscription that you will be able to use
throughout this book, then introduce the Azure portal to interact with it. Azure Data
Factory Studio (introduced later in the chapter) is only supported in Microsoft Edge or
Google Chrome, so you will need to use one of those two web browsers. If you don’t
already have a Microsoft account, you can create one at https://signup.live.com/.

Create a Free Azure Account


Many of the exercises in the book require elevated access permissions in Azure. You may
choose to skip this section if you already have an Azure subscription that you would prefer
to use, but make sure that it grants you sufficient access to create and modify resources.

1. In your chosen web browser, go to https://azure.microsoft.


com. Click the Free account button in the top right.

2. On the following page, click Start free. If you aren’t already logged
in, you will be prompted to sign into a Microsoft acount.

3. Follow the two-page process to set up your account. During the


account setup, you will be required to provide billing information,
but your credit card will not be charged unless you upgrade to a
paying subscription.

After successful account creation, a Go to Azure portal button is displayed – click it.
If you don’t see the button, you can browse to the portal directly using its URL: https://
portal.azure.com. You may be directed to the portal’s “Quickstart Center” – if so, select
Home from the hamburger menu in the top left.

2
Chapter 1 Creating an Azure Data Factory Instance

Explore the Azure Portal


The Azure portal is where you manage all your Azure resources. You’ll use the portal
regularly, so it’s a good idea to bookmark this page. The portal home page looks something
like Figure 1-1. I say “something like” because you may see different tools, recommendations,
links, or other messages from time to time. Three features are always present:

1. In the top left of the home page, you will find a Create a resource
button (“plus” icon). This option is also available from the portal
menu, accessed using the hamburger button in the top left.

2. In the top right, the email address you used to sign in is displayed.

3. Immediately below your email address is your current directory.


If you are using a free trial subscription, this will say DEFAULT
DIRECTORY.

Figure 1-1. Azure portal home page

Your directory, commonly called a tenant, is an instance of Microsoft Entra ID,


formerly known as Azure Active Directory (AAD). “Default Directory” is the default name
of a new tenant. If you are already using Azure in your job, you will probably be using
a tenant that represents your company or organization – often, all of an organization’s
Azure resources and users are defined in the same single tenant.
3
Chapter 1 Creating an Azure Data Factory Instance

Note The Azure Active Directory service was renamed Microsoft Entra ID during
2023. You may occasionally find Microsoft services or documentation which
make reference to Azure Active Directory, or to AAD – these should be understood
to refer to Microsoft Entra ID and will be updated over time.

A tenant contains one or more subscriptions. A subscription identifies a means


of payment for Azure services – the cost of using any Azure resource is billed to the
subscription with which it is associated. An Azure trial subscription includes an amount
of time-limited free credit, and if you want to spend more, you can do so by upgrading
to a paying subscription. Your organization might have multiple subscriptions, perhaps
identifying separate budget holders responsible for paying for different resources.
If you have created a free trial subscription, you can see the amount of credit
remaining as follows:

1. Click the Subscriptions icon (to the right of the Create a resource
button in Figure 1-1). If you can’t see the icon, use the search bar
at the top of the portal.

2. The Subscriptions blade is displayed, showing the free trial


subscription. Click the link to the subscription (in the Subscription
name column) to access more detail.

3. After a few moments, a pop-up banner is displayed, indicating


the amount of credit remaining. Figure 1-2 shows a newly created
subscription in which $200 of credit is available.

4
Chapter 1 Creating an Azure Data Factory Instance

Figure 1-2. Remaining credit in Azure subscription

Signing up for a trial Azure subscription creates a number of things, including

• An Azure tenant

• An Azure subscription in the tenant with some time-limited free


credit for you to use

• Your Azure user account, with administrator-level Microsoft Entra


ID permissions inside the tenant

Create a Resource Group


Instances of Azure services are referred to generally as resources. An instance of Azure
Data Factory is an example of a resource. Resources belonging to a subscription are
organized further into resource groups. A resource group is a logical container used to
collect together related resources – for example, all the resources that belong to a data
warehousing or analytics platform.
Figure 1-3 illustrates the logical grouping of resources in Azure. In this section, you
will create a resource group to contain an ADF instance and other resources that will be
required in later chapters.

5
Chapter 1 Creating an Azure Data Factory Instance

Figure 1-3. Logical resource grouping in Azure

1. Click Create a resource, using either the button on the portal home
page or the menu button in the top left.

2. Resource management pages in the Azure portal are referred to


as blades – the new resource blade is shown in Figure 1-4. You
can browse available services using the Popular Azure services
icons (filtered using the Categories sidebar), or you can use the
Search services and marketplace function. In the search box, enter
“resource group” (without the quotes).

6
Chapter 1 Creating an Azure Data Factory Instance

Figure 1-4. New resource blade

3. As you type, a filtered dropdown menu will appear. When you see
the “resource group” menu item, click it. This takes you to a list of
matching resource types available in the Azure marketplace, as
shown in Figure 1-5.

7
Chapter 1 Creating an Azure Data Factory Instance

Figure 1-5. Marketplace search results

4. Marketplace search results are presented as tiles – click the


Create dropdown on the Resource group tile (also shown in
Figure 1-5) and select Resource group to begin creation of a new
resource group.
5. Complete the fields on the Create a resource group blade, shown
in Figure 1-6. Ensure that your trial subscription is selected in
the Subscription field, and provide a name for the new resource
group. I use resource group names ending in “-rg” to make it
easy to see what kind of Azure resource this is. Choose a Region
geographically close to you – mine is “(Europe) UK South,” but
yours may differ. When you are ready, click Review + create.

8
Chapter 1 Creating an Azure Data Factory Instance

Figure 1-6. Create a resource group blade

6. On the Review + create tab which follows, check the details you
have entered, then click Create.

Note You will notice that I have skipped the Tags tab. In an enterprise
environment, tags are useful for labeling resources in different ways – for
example, allocating resources to cost centers within a subscription or flagging
development-only resources to enable them to be stopped automatically overnight
and at weekends. I won’t be using tags in this book, but your company may use a
resource tagging policy to meet requirements like these.

Create an Azure Data Factory


The resource group you created in the previous section is a container for Azure resources
of any kind. In this section, you will create the group’s first new resource – an instance of
Azure Data Factory.

9
Chapter 1 Creating an Azure Data Factory Instance

1. Go back to the Azure portal home page and click Create a resource,
in the same way you did when creating your resource group.

2. In the Search services and marketplace box on the Create a


resource blade, enter “data factory”. When “data factory” appears
as an item in the dropdown menu, select it.

3. Find the Data Factory tile in the marketplace search results, then
select Data Factory from the tile’s Create dropdown.

4. The Basics tab of the Create Data Factory blade is displayed, as shown
in Figure 1-7. Select the Subscription and Resource group you created
earlier, then choose the Region that is geographically closest to you.

Figure 1-7. Create Data Factory blade


5. Choose a Name for your ADF instance. Data factory names can
only contain alphanumeric characters and hyphens and must
be globally unique across Azure – your choice of name will not
be available if someone else is already using it. I use data factory
names ending in “-adf” to make it easy to see what kind of Azure
resource this is.
10
Chapter 1 Creating an Azure Data Factory Instance

6. Version is set automatically to “V2.” (It is no longer possible to


create instances of ADF V1, and this book is concerned exclusively
with Azure Data Factory V2).

7. Click the Next button, then on the Git configuration tab, ensure
that the Configure Git later check box is ticked.

8. Finally, click Review + create, check the factory settings you


provided in steps 4 to 7, then click Create to start deployment. (I
am purposely bypassing the three remaining tabs – Networking,
Advanced, and Tags – and accepting their default values).

When deployment starts, a new blade containing the message Deployment is in


progress is displayed. Creation of a new ADF instance usually takes no more than 30
seconds, after which the message Your deployment is complete will be displayed, as
shown in Figure 1-8. Click Go to resource (indicated in the figure) to inspect your new
data factory.

Figure 1-8. ADF deployment blade

The portal blade displayed when you click Go to resource provides an overview of
your data factory instance. It contains access controls and other standard Azure resource
tools, along with monitoring information and basic details about the factory – for
example, its subscription, resource group, and location.

11
Random documents with unrelated
content Scribd suggests to you:
The Project Gutenberg eBook of Kokki-kirja
This ebook is for the use of anyone anywhere in the United States
and most other parts of the world at no cost and with almost no
restrictions whatsoever. You may copy it, give it away or re-use it
under the terms of the Project Gutenberg License included with this
ebook or online at www.gutenberg.org. If you are not located in the
United States, you will have to check the laws of the country where
you are located before using this eBook.

Title: Kokki-kirja
elikkä Neuvoja tarpeellisempien Joka-aikaisten Pitoruokien
Laitokseen

Editor: J. F. Granlund

Release date: April 22, 2024 [eBook #73445]

Language: Finnish

Original publication: Turku: J. S. Frenckell ja Poika, 1849

Credits: Tuula Temonen

*** START OF THE PROJECT GUTENBERG EBOOK KOKKI-KIRJA


***
KOKKI-KIRJA

elikkä

Neuvoja tarpeellisempien Joka-aikaisien- ja Pito-ruokien


Laitokseen, niin myös Monellaisiin leipomisiin ja juotavien panoin,
ynnä Tarpeellisia tietoja ruokien ja ruoka-aineiden korjusta ja
säästystä j.n.e.

Kirj.

J. F. GRANLUND

Turussa, J. E. Frenckelin ja Pojan kirja-painossa, 1849.


SISÄLLYS.

Oudompien sanojen selitykset.


Johto.
1. Astioiden ruokosta.
2. Keitto-puista.
Ruoka-vesistä.
3. Ruoka-aineiden korjusta.
4. Ruokien laitoksesta.
1:nen Jako.
Soppia ja Maito-ruokia.
2:nen Jako.
Liha-ruokia.
A) Här'än-lihoja.
B) Vasikan-lihoja.
C) Lampaan-lihoja.
D) Sian-lihoja.
E) Mettän-elävien-lihoja.
F) Linnun-lihoja.
Sylttyjä.
3:mas Jako.
Kala-ruokia.
4:jäs Jako.
Muna-ruokia.
5:des Jako.
Ruokia juuri- ja vihriäis-kasvuista.
6:des Jako.
Kaikellaisia Sallatteja.
7:mäs Jako.
Putinkeja.
8:sas Jako.
Kasia.
9:säs Jako.
Makkaroita.
10:nes Jako.
Pasteijoja, Torttuja, Paakkelseja, Pannukakkoja ja Kräämejä.
A) Pasteijoja elikkä Ispinöitä.
B) Torttuja.
C) Paakkelseja elikkä Kahkaroita.
D) Pannukakkoja.
E) Kräämejä.
11:ta Jako.
Marja-hillojen keitoksista. Ruoka-hedelmöiden astioittemisesta
säästymään, niiden suolaamisesta ja kuivaamisesta.
A) Marja-hillojen keitoksesta.
B) Ruoka-hedelmöiden astioittemisesta säästymään.
12:ta Jako.
Lihojen suolaamisesta ja sauhuttamisesta.
13:ta Jako.
Leipomisista.
14:ta Jako.
Oluen panosta ja kaikellaisien muiden juotavien teosta.
15:ta Jako.
Muutamien Ruoka-aineiden teosta ja säästöstä, niin myös
tarpeellisia
tietoja ruokien korjusta. Ruokien-nautinnon-järjestys.
Reisteri.

Oudompien sanojen selitykset.

Vaikk'ei tässä kirjassa ole luulaksemme puolikuntasillekkaan


suomalaisille' yhtään ymmärtämätöntä sanaa, niin tahdomme
kuitenkin ruottistuneiden kokkien hyödyksi selittää, mitä emme luule
muutoin ymmärtävänsä. — Kirjassa selitetyt sanat ovat tästä pois
jätetyt.

Astioittu — se on: astioihin pantu hyvänä pysymään. Ruott. kiel.


Inlagd.
Haarake' — se on kahveli.
Hillo — Ruottin kiel. Sylt.
Marja-hilloa — se on marja-sylttyä.
Huhmari — s.o. mortteli.
Höystötys — Ruott. k. Stufning.
Höystettyä — Ruottiksi Stufvad.
Inkivääri — Ruott. Ingefära.
Kaava — s.o. vormu. Ruott. Form.
Karvaat-pippurat — mustat-pippurat.
Kasi — soosi.
Kehlo — Ruott. Bunke.
Keuhko-ruoka — Ruott. Lungmos.
Kokkara — s.o. klimppi, myöskin frikadelli.
Kuurnataan — s.o. siilataan.
Kylmä-liemi — Ruott. Kallskäl.
Kynsilaukka — Ruott. Hvitlök.
Lautas-liina — salvetti, Ruottiksi Serviet.
Leivin-pyörin — s.o. käsivarren-vahvunen ymmyriäinen kapula, jolla
leivintaikinaa vaivataan; Ruott. Kafvel.
Liha-kakko — Ruott. Köttbulle.
Liikkiö, pöysti — se on kinkku, sinkku.
Lyöpätään — Ruott. Förvällas.
Mäihä-rauta — raastin, se on riivin-rauta.
Neste' — Ruott. Saft.
Olut-juusto — Ruott. Ölost.
Olut-keitos — Ruott. Ölsupa.
Osa, ruoka-osa — Ruott. Portion.
Pannukakko-lasta — lasta, jolla pannukakkoja käännetään
paistaissa;
Ruott. Pankaksspade.
Parilas — halstari.
Parrisa — Ruott. Sparris.
Porkkana — muuruutti.
Pulli — purkki.
Pullo — potelli.
Puna-juurikka — röbetta.
Purju-laukka — Ruott. Purlök.
Putinki — Ruott. Budding.
Pyyhin-liina — pyhkiys-liina, hantuukki.
Pöysti, liikkiö — kinkku, sinkku.
Pöytä-vaate' — tuukki.
Raastin — mäihä-rauta, riivin-rauta.
Raastittua — se on: riivin-raudalla riivattua.
Runsitaan — s.o. ruokotaan puhtaaksi; Ruott. Skrädas
Ruoka-pippurat — kryyti-pippurat.
Ruoka-siivilä — Ruott. Durkslag.
Räätikkä — juurikas.
Sahrami — Ruottiksi; Saffram.
Sipuli — Ruott. Rödlök.
Suurustus — Ruott. Afredning.
Suurustetaan — Ruott. Afredas.
Sysiä — suuria hiiliä.
Taale' — kerma, Ruott. Gredda.
Varikoinen — makosen-hapan, R. Sötsur.
Varistin — se on: lävellinen hopea-lusikka, jolla sokeria varistetaan
ruokiin; Ruott. Strösked.
Vohvula — Ruott. Voffla.
Vänkkooli — Ruott. Fenkol.

Johto.

1. Astioiden ruokosta.

Keittäjän tulee pitää ruoka- ja keitto-astiat erinomasen hyvässä ja


puhtaassa ruokossa.

Kupari- taikka Vaski-astiat ovat paraita keitto-kaluja, ollenkin


muna- ja maito-ru'issa, mutta niiden pitää aina oleman hyviksi
tinattuja, eikä koskaan tinaamattomissa, ei huonoiksi tinatuissakaan,
ei soenneissa eikä pesemättömissä keitettämän; sillä kuparin
vihriäinen ruoste, joka tinaamattomista lähtee, on väkevää myrkkyä.
Valkialle' pantaissa pitää tinatuissa oleman märkyyttä estämässä
tinan sulausta. Uudesta tinattu astia pitää hyvästi vedessä
keitettämän, ennen kuin ruokiin pannaan. Puhtaiksi saadaan ne'
sahan-jauhoilla, taikka vielä puhtaimmiksi trankilla eli vanhalla
happamalla juomisella. Samalla puhdistetaan myös messinki.

Rauta-pannut ja Padat ovat keitto-astioina huonompia; ne'


ruostuuvat helpommin, muuttaavat ru'an ja ovat työlläästi
puhdistettavia. Puhtaiksi saatuna, ja uutena, estetään ne'
ruostumasta sian-silavalla taikka ihralla voidellen. Muuloistin pestään
ne' paljaalla lipiällä ja sitte' virutetaan vedellä. Tuh'alla ja vedellä
lähteevät ne' myös puhtaiksi, taikka pienennetyllä ja seulotulla
tiilikivellä, jota aina pitäisi olla käsillä.

Kivi- taikka Savi-astiat ovat hyviä keitto- ja ruoka-astioiksi, ja


rautalangalla niottuina eivät pääse halkeilemaankaan. Vielä
paremmin estyyvät ne' halkeilemasta, jos ulkopuolelta muutamaan
piihin silataan vetelällä savella ja sitte' liinöljyllä. Ja jos ne' ensin
uutena muutamaksi hetkeksi täytetään kylmällä vedellä ja sitte'
keitetään hiljaksellen padassa, niin eivät muuta ru'an makua.
Lämpösinä lähteevät ne' puhtaiksi listimillä taikka Nisun-kliideillä.
Vanhana pitää ne' usiasti keitettämän lipiässä; taikka ne' muuttaavat
ru'an pahanmakuseksi.

Tina-astiat puhdistetaan väkevään lipiään ja hietaan, taikka


pieneen santaan, kastetulla villasella rievulla, jonka perästä ne'
virutetaan.

Posliinit estetään säröilemästä, jos vähän lämmitetään ennen kuin


kuumiin aineisiin pannaan. Ne' puhdistetaan lipiällä taikka
lämpösellä vedellä.

Klasi-astiat lähteevät kylmällä vedellä ja suoloilla, mutta jos ovat


rasvasia, niin pestään ne' harmaalla villamaisella paperilla, sannalla
ja hauleilla. Himmiintyneet juoma-klasit saadaan kirkkaiksi, jos
tuliselle' hiilustalle' kaadetaan vettä ja pidetään klasit siinnä
nousevassa höyryssä.

Pöytä-hopea puhdistetaan pesten paljaalla kuumalla vedellä ja


liina- taikka villa-rievulla, ilman saippuaa taikka soopaa. Pyhitään
sitte' kuiviksi ja puhtaiksi talista taikka vaksista; sen perästä otetaan
poltettua ja hyvin pieneksi jauhoksi hakattua peuransarvea ja
lampaanluuta, joihinka vanha kulunut liinanriepu kastetaan ja
hiastetaan sillä hopeat kirkkaiksi. Jota useammin sama riepu tähän
viljellään, sitä kirkkaimmaksi tuleevat sillä hopiat. Sitä ei pidä
hukattaman, vaikka soenneeltakin näyttää, vaan säilytettämän
kokoonpantuna liinasessa rievussa, ett'ei tahriintuisi. — Poltettua ja
pienettyä peuransarvea saadaan Apteikista.

Pullot suullistetaan keitetyillä korkeilla, lyöden puu-nuijalla lujaan,


ennen kuin ehtiivät ylöllensä vettyä ja paisua.

Paot, metalli- ja kivi-astioissa, tukitaan vettäpitäväisiksi kyrsällä,


tehty puoliksi tuh'asta ja pajan-miilusta sekotettu munan-valkuaisella.

2. Keitto-puista ja Ruoka-vesistä.

Keitto-puina liedellä ovat koivuset paraita; niillä saadaan isompi ja


tasasempi kuumuus kuin mäntysillä ja kuusisilla. Uuni-puina sopii
olla mitähyvänsä.

Kovasta vedestä ei ole kaloille' eikä palko-kasvuille'; sillä siinnä


eivät ne' pitkälliselläkään kiehumisella pehmene. Muutamat vedet
muuttavat kalat punasiksi, ja semmoiset eivät ollenkaan sovi palko-
kasvuille'. Hyvä vesi on selkiää, väritöntä ja mautonta, köykästä ja
helmeilee pudistaissa.

Ruoppanen- ja samia-vesi selkenee, jos tulisia rautoja taikka sysiä


sammutetaan siinnä usiat kerrat peräksyttäsin. Taikka jos klasillinen
hyvää palo-viinaa kaadetaan huonoon veteen, niin selkiä se
pikemmin.

3. Ruoka-aineiden korjusta.

Kylmässä huoneessa tuoreena säästettäviä lihoja ei suolata, vaan


pannaan ylös roikkumaan, ett'eivät saa maata. Tämä ei ole
kuitenkaan sanottu mettään-saalliista eikä sian-lihasta.

Mettän-saallis pestään puhtaaksi verestä, erinomattain pyssyn-


haava.
Jonkuun ajan säilyy se hyvänä käärittynä puhtaassa rievussa.

Vanhan sianliha säilyy hyvänä usiat viikot kiviastiassa suoloissa ja


katajan-marjoissa.

Här'än-, vasikan- ja karittan-lihoja on paras säilyttää kuivaamalla,


niin pysyyvät mehukkaampina. Niistä tulee sitte' myöskin
voimallisempaa soppaa, ja valkosempaa ja maukkaampaa
paistiakin.
Lintu noukitaan ja avataan kuivana ja lämpösenä, ennen
kankistumistansa. Suvella pantuna ylös roikkumaan ja talvella
kokonaisena jäädyttämisellä saadaan se hyväksi ja hauraaksi.

Sipulit ja kynsilaukat säilytetään kuorinensa kuivalla paikalla


pikkusissa kimpuissa roikkumassa.

Kaikellaisien kasvujen, jauhojen ja munien säilytyksestä, niinkuin


myöskin lihojen suolaamisista ja sauhuttamisista puhutaan kirjan
lopulla.

4. Ruokien laitoksista.

Soppaan pantavaa lihaa ei pestä lämpösellä vaan kylmällä


vedellä, mutta ei silläkään ylöllensä, sillä pitkällinen peseminen ja
vetyttäminen vie lihasta paraan maun.

Liha suolataan parahultasesti ennen keittämistä, ja pannaan


kiehumaan kylmään veteen valkialle; siittä haurastuu se pikemmin,
ja soppa, niinkun puljonkikin, tulee selkiämmäksi ja paremmaksi.
Kiehumaan ruvetessa kuoritaan ahkeraa päälle' nouseva maanto, ja
persilja, palsternakat, ja muut sellaiset, pannaan sekaan. Vähän
ajantakaa otetaan rasva pois, mutta liha kiehutetaan sentään
vitkallensa umpi-kannen alla, ett'ei sopasta voima ja maku katoisi.
Pippurit ja muut kryydit pannaan kokonaisina, eikä pienennettyinä;
sillä kokonaiset antaavat vähemmästä voimansa kuin pienetyt.
Valmiiksi keitettynä siilataan ne' sopasta pois.
Vasikan-, karittan- ja linnun-paisteja ei saada ylöllensä pestä, ei
myöskään järki aikasin suolata; sillä suola imee niistä paraan
voiman. Jota pitkällisemmin paisti paistetaan, sitä hauraammaksi ja
mäihäkkäämmäksi liha tulee.

Uuni-paistit pitää usiasti käännettämän ja voideltaman, taikka


valettaman omalla kasellansa. Vielä tyystemmin on valaminen
vaariin otettava varras-paistissa.

Kalat pitää, niinkuin lihatkin, suolattaman ennen keittämistä


parahultasen aikasin. Jos ne' suolattomassa vedessä keitetään, niin
saavat vettyneen maun. Kiehuessa kuoritaan pois kaikki päälle'
kuohuva maanto. — Hauki on 3:men ja 4:jän naulan painosena
maukkaampi.

Lohi-sallattiin ja muihin semmoisiin ei kaadeta etikkaa eikä öljyä,


vaan ne' pannaan erinänsä ruoka-lain kanssa pöytään, josta kukin
saa ottaa mielensä perästä.

Kupu-kaalit ja muutamat muutkin kasvut vanhentuneena lyöpätään


ensiksi, sitte' virutetaan raikkaalla vedellä ja viimmeseksi keitetään.

Parrisat, kukka-kaalit ja penaatti lyöpätään ennen keittämistä


suolasessa vedessä, mutta ei rauta-pannussa, joka ne' mustastii.

Palko-kasvut, niinkuin pavut, pöönit, hiiren-pavut (elikkä Linsit)


pannaan valkialle' kylmään veteen kiehumaan. Ne pehmeneevät
pikemmin virta- kuin kaivo-vedessä.

Perunoita keitettäköön vähässä vedessä, niin että päällimmäiset


tuskin ovat veden alla, ja lisättäköön sen jälkeen toista, kuin se
kiehuessa vähenee. Älköön myös isoja ja pikkuisia sekasin
keitettäkö, vaan kummatkin erinänsä; sillä sekasin keitettyinä
kiehuuvat pikkuset sakaksi, ennenkuin isot ovat ehtineet
puolikypsiksikään. — Muutamissa perunoissa on maan maku,
sentähden keitettäköön niitä ensimmäisessä vedessä ainoastansa
muutama minuutti ja muutettakoon sitte' toiseen, jossa kiehukoot
kypsiksi. Jos niihin varistellaan hiukan suoloja, sitte' kuin ovat
muutaman minuutin kiehuneet, niin tuleevat ne' paremman
makusiksi. — Kuminoita taikka tinjamia ei ole sekaan panemista,
enempää kuin muitakaan kryydejä, sillä ne' huonontaavat
perunoiden maun.

Kaikkein paras on keittää perunoita höyryssä, sillä se ei hävitä niin


paljon puita eikä aikaa kuin vedessä keittäminen; perunat tuleevat
myös sillä lailla paremman makusiksi. Tämä tapahtuu seuraavalla
lailla: Padan pohjalle' kaadetaan tuumaa vahvalle' vettä, sen päälle'
lasketaan vahvasta rautalangasta kudottu tihku häkki, jonka päälle'
kaadetaan perunoita pata täyteen. Padansuu peitetään mär'ällä
kankaalla ja lasketaan päälle' hyvin sopiva kansi. Valkia pitää aina
pidettämän niin padan alla, ett'ei liekki ollenkaan laitoin pääse.
Pidettäköön myös perunat muutama tunti vedessä, ennen kuin
pataan pannaan.

Jos leivottuja aineita tahdotaan kypsentää tina- taikka posliini-


astioilla uunissa, niin pannan ne' suoloilla priiskotetuille' vahvoille'
rauta-pelleille', jotka estäävät astiat särkymästä.

1:nen Jako.
SOPPIA JA MAITO-RUOKIA.

Muistutus. Kokkaroista (klimpeistä) ja muista Soppiin ja Puljonkeihin


pantavista puhutaan tämän Jaon lopulla, N:o 44 ja seur.

N:o 1. Tavallista Puljonkia elikkä Lihanlientä.

Hyväksi pestyä Här'än-lihaa pannaan puhtaaseen kattilaan


kiehumaan umpikannen ale hyppysellisen suolan kanssa, ja niin
paljon vettä, että liha on peitossa. Sitte', kuin kiehuessa maanto on
päältä kuorittu, pannaan sekaan hiukan kokonaisia kryydipippuroita,
pari palasta inkivääriä, yksi puurlaukka ja persiljanjuuri. Kuin liha on
kypsynyt ja liemi tullut parahultasen väkeväksi, niin kuurnataan
(elikkä siilataan) se jähtymään taajan ruokasiivilän elikkä liinasen
läpitte' ja kuoritaan sitte' kaikki rasva päältä pois. Tätä lientä, joka nyt
on valmista, kutsutaan puljongiksi. Jos puljonki tahdotaan sopaksi,
niin käristetään, taikka sulatetaan, sekasin voita, jauhoja ja hiukan
pienennettyä persiljaa, joka kaadetaan sitte' liemeen ja sekotetaan
vispilällä sekasin. Tämä on kiehuttuansa valmista, ja eteentuotava
paistettujen leipä-pytkyjen joukossa taikka kokkaroiden.

N:o 2. Tavallista Liha-Soppaa.


Liha keitetään edellä mainitulla tavalla, ainoastansa sillä
erotuksella, että tähän lisätään 3 porkkanaa (taikka muuruutia) ja 2
palsternakkaa, jonka perästä liha ja liemi kuurnataan, ja porkkanat ja
palsternakat ruokotaan puhtaiksi. Soppa suurustetaan sitte' samalla
lailla kuin edellä mainittu (N:o 1) ja kaadetaan pöydälle' tuotavaan
ruoka-astiaan, johonka jo mainitut juurikasvut ovat pieninä lohkoina
pantu. Muskottia raastitaan viimmeseksi sekaan, ja soppa tuodaan
eteen kokkaroinensa (klimppinensä) taikka ilman kokkaroita.

N:o 3. Vasikanlihasta Puljonkia.

Här'än-lihan verosta otetaan vasikan-lihaa, taikka sekasin


molempia; valmistetaan sitte' samalla lailla kuin N:o 1.

N:o 4 Selkiää Puljonkia

Teekupeista nautittavaa.

Liha keitetään samalla lailla ja samoissa aineissa kuin N:o 1. Kuin


puljonki on valmista, jähtynyt ja rasva pois kuorittu, sekotetaan siihen
muutama vahdoksi vispilöitty munan-valkuainen selitykseksi,
pannaan sitte' äkkikuumuuteen kiehumaan pikasesti, ja muodon
muutteeksi kaadetaan sekaan muutama pisara poltetun sokerin
lientä. Sitte' kuurnataan se moneen piihin villasen kankaan läpitte',
siksi että selkenee, jonka perästä keitetään ja tuodaan teekupeilla
eteen.

N:o 5. Kellasta Puljonkia.


Kolme taikka neljä munan-ruskuaista, hakattuna sekasin ruoka-
astiassa, pannaan tavalliseen puljonkiin (N:o 1) ja raastitaan sitte'
päälle' muskottia.

N:o 6. Kakko-puljonkia elikkä Liemi-kakkoa. (Bouillon de Poche).

Tuoretta här'än- ja vasikan-lihaa, 12 naulaa kumpaakin, ja niin


paljon yty-luita kuin saadaan, kaksi taikka kolme vanhaa kanaa
luinensa, säärinensä ja siipitankonensa, niin myös neljä hyväksi
kaltattua vasikan jalkaa hakataan pieniksi palasiksi, pestään hyvin
puhtaiksi haliassa vedessä ja pannaan sitte' kylmään veteen
hyppysellisen suolan kanssa kiehumaan hyväksi tinattuun kattilaan.
Kiehuessa kuoritaan maanto päältä pois, ja pannaan sekaan pari
purjulaukkaa, pari persiljanjuurta, vähän kokonaisia kryydipippuroita
ja inkivääriä; keitetään sitte' hiljasella valkialla hyvän umpikannen
alla siksi että liha on ehtinyt mäihääntyä ja liemi kiehua kolmen
toopin vähyyteen, joka sitte' juoksutetaan tihuan jouhiseulan läpitte'
ja kaikki rasva kuoritaan tyystin pois. Tämä puljonki pannaan nyt
toistamiseen kiehumaan kastrulliin ja sekotetaan, ett'ei saku päälle'
selkiäisi, ja keitetään siksi, että tuskin toopin verta on jäljellä. Se
kaadetaan sitte' tina-tooppiin, ja tina-tooppi pannaan oikopäätä
kiehuvaan vesikattilaan, jonka pitää sillä hetkellä oleman saapuilla
kiehumassa. Siinnä sitä sitte' keitetään hiljasella valkialla, pari tuntia
yhtämittaa, ja sekotetaan ahkeraa, että pysyy sekasena, ja pidetään
tarkka vaari ett'ei vesi kattilasta pääse tooppiin. Määrätyn ajan
kiehuttuansa on se vetelän puuron sakusta, jona se kaadetaan
jähtymään posliini vadille'; siinnä hyydyttyänsä leikataan ohkosiin
pytkyihin, pannaan paperille' kuivamaan parahultasen lämpöselle'
paikalle', mutta ei kuumalle', ja käännellään välistä, ett'eivät paperiin
tarttuisi. Näitä pytkyjä sopii säästä, ja kuljettaa matkoillakin
muassansa, sillä niistä saadaan pikasesti nautittavaa, koska ei
siihen muuta tarvita kuin kiehunutta vettä, johonka näitä pytkyjä
pannaan senjälkeen kuinka väkeväksi puljonki tahdotaan.

N:o 7. Lampaanliha-Soppaa.

Kuin soppa on kiehunut ja kuorittu kuohu pois, pannaan siihen


hiukan sipulia, palanen inkivääriä ja muutama kokonainen
kryydipippura; lihan näissä kypseksi kiehuttua, kuurnataan soppa
ruoka-siivilän läpitte' ja suurustetaan hiukalla voilla, persiljalla ja
jauhoilla. Tähän lisätään vielä kuorittuja ja nelistahkuliaisiksi
leikattuja nuoria nauriin-lohkoja ja portlakan lehtiä. Liha jätetään
myös palasina soppaan ja kaadetaan ruoka-astiaan eteen
tuotavaksi, sitte' kuin siihen on ensin raastittu hiukan muskottia. Jos
liha pois-otetaan, niin pannaan niitä juuri-kasvuja sen siaan, kuin
edellä mainittuin soppiin on määrätty.

N:o 8. Porsaanliha-Soppaa.

Lihava maito-porsas ruokotaan ja pestään hyvin puhtaaksi, siittä


otetaan sitte' puoli, taikka senverran kuin tarvitaan, ja hakataan
parahultasiin palasihin. Pää halastaan kahtia ja otetaan aivut pois,
pestään sitte' puhtoseksi ja pannaan kylmään veteen kiehumaan.
Kiehuessa kuoritaan tyystästi maanto päältä ja pannaan sekaan
inkiväärin palasia, ruokapippuroita, sipulia ja suoloja. Lihan kypseksi
kiehuttua kuurnataan soppa ja pannaan pataan takasin;
suurustetaan sitte' yhteensekotetulla taaleella, munan-ruskuaisella,
etikalla ja nisujauhoilla. Liha pannaan vatiin ja soppa kaadetaan
päälle', viimmeksi raastitaan muskottia joukkoon.
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and


personal growth!

textbookfull.com

You might also like