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

Instant Download Beginning Azure Static Web Apps: Building and Deploying Dynamic Web Applications with Blazor 1st Edition Stacy Cashmore PDF All Chapters

Beginning

Uploaded by

addoupld
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (1 vote)
56 views

Instant Download Beginning Azure Static Web Apps: Building and Deploying Dynamic Web Applications with Blazor 1st Edition Stacy Cashmore PDF All Chapters

Beginning

Uploaded by

addoupld
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 55

Download Full Version ebook - Visit ebookmeta.

com

Beginning Azure Static Web Apps: Building and


Deploying Dynamic Web Applications with Blazor 1st
Edition Stacy Cashmore

https://ebookmeta.com/product/beginning-azure-static-web-
apps-building-and-deploying-dynamic-web-applications-with-
blazor-1st-edition-stacy-cashmore/

OR CLICK HERE

DOWLOAD NOW

Discover More Ebook - Explore Now at ebookmeta.com


Instant digital products (PDF, ePub, MOBI) ready for you
Download now and discover formats that fit your needs...

Start reading on any device today!

Beginning Azure Static Web Apps: Building and Deploying


Dynamic Web Applications with Blazor 1st Edition Stacy
Cashmore
https://ebookmeta.com/product/beginning-azure-static-web-apps-
building-and-deploying-dynamic-web-applications-with-blazor-1st-
edition-stacy-cashmore-2/
ebookmeta.com

Building Modern Web Applications with ASP NET Core Blazor


Learn how to use Blazor to create powerful responsive and
engaging web applications Brian Ding
https://ebookmeta.com/product/building-modern-web-applications-with-
asp-net-core-blazor-learn-how-to-use-blazor-to-create-powerful-
responsive-and-engaging-web-applications-brian-ding/
ebookmeta.com

Microsoft Blazor: Building Web Applications in .NET -


Second Edition Peter Himschoot

https://ebookmeta.com/product/microsoft-blazor-building-web-
applications-in-net-second-edition-peter-himschoot/

ebookmeta.com

Statecraft and the Political Economy of Capitalism 1st


Edition Scott G. Nelson

https://ebookmeta.com/product/statecraft-and-the-political-economy-of-
capitalism-1st-edition-scott-g-nelson/

ebookmeta.com
Do Android Girls Need Oil Changes Vol 1 A. R. Cevlar

https://ebookmeta.com/product/do-android-girls-need-oil-changes-
vol-1-a-r-cevlar/

ebookmeta.com

The Cambridge Handbook of Material Culture Studies


Cambridge Handbooks in Anthropology Lu Ann De Cunzo

https://ebookmeta.com/product/the-cambridge-handbook-of-material-
culture-studies-cambridge-handbooks-in-anthropology-lu-ann-de-cunzo/

ebookmeta.com

The Four Pillars of Investing: Lessons for Building a


Winning Portfolio, 2nd Edition William J. Bernstein

https://ebookmeta.com/product/the-four-pillars-of-investing-lessons-
for-building-a-winning-portfolio-2nd-edition-william-j-bernstein/

ebookmeta.com

101 Cases in Respiratory Medicine 1st Edition Supriya


Sarkar

https://ebookmeta.com/product/101-cases-in-respiratory-medicine-1st-
edition-supriya-sarkar/

ebookmeta.com

The Psychology of Dictatorship 1st Edition Fathali M.


Moghaddam

https://ebookmeta.com/product/the-psychology-of-dictatorship-1st-
edition-fathali-m-moghaddam/

ebookmeta.com
The Artist 1st Edition Sheri Lewis Wohl

https://ebookmeta.com/product/the-artist-1st-edition-sheri-lewis-wohl/

ebookmeta.com
Beginning Azure
Static Web Apps
Building and Deploying Dynamic
Web Applications with Blazor

Stacy Cashmore
Beginning Azure Static Web Apps: Building and Deploying Dynamic Web
Applications with Blazor

Stacy Cashmore
Amsterdam, The Netherlands

ISBN-13 (pbk): 978-1-4842-8145-1 ISBN-13 (electronic): 978-1-4842-8146-8


https://doi.org/10.1007/978-1-4842-8146-8
Copyright © 2022 by Stacy Cashmore
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: Shrikant Vishwakarma
Cover designed by eStudioCalamar
Cover image designed by Pexels
Distributed to the book trade worldwide by Springer Science+Business Media LLC, 1 New York Plaza, Suite
4600, New York, NY 10004. Phone 1-800-SPRINGER, fax (201) 348-4505, email orders-ny@springer-sbm.
com, 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 booktranslations@springernature.com; for reprint,
paperback, or audio rights, please e-mail bookpermissions@springernature.com, or visit http://www.apress.
com/rights-permissions.
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 via the book’s product page, located at https://link.springer.com/book/10.1007/
978-1-4842-8145-1.
Printed on acid-free paper
Dedication
To Dad, one of the last things that you said to me was that if I put my
mind to do something, you had no doubt it would be done.
I said that I didn’t believe it. Well… I’ve somehow managed to write
this book and wish that you were here to see it. Miss you.
To my partner and child, I know that you want to
remain anonymous, but I couldn’t not dedicate this book
to you as well. Thanks for putting up with me. Love you both!
Table of Contents
About the Author��������������������������������������������������������������������������������������������������� xiii

About the Technical Reviewers�������������������������������������������������������������������������������xv


Acknowledgments�������������������������������������������������������������������������������������������������xvii

Part I: Getting Started������������������������������������������������������������������������������������� 1


Chapter 1: Introduction�������������������������������������������������������������������������������������������� 3
JamStack�������������������������������������������������������������������������������������������������������������������������������������� 3
BlamStack������������������������������������������������������������������������������������������������������������������������������������� 4
Azure Static Web Apps������������������������������������������������������������������������������������������������������������������ 4
Book Focus����������������������������������������������������������������������������������������������������������������������������������� 5
Let’s Get Started!�������������������������������������������������������������������������������������������������������������������������� 6

Chapter 2: Setting Up the Environment�������������������������������������������������������������������� 7


Microsoft Account and Azure Subscription����������������������������������������������������������������������������������� 8
GitHub Account����������������������������������������������������������������������������������������������������������������������������� 9
GitHub Repo�������������������������������������������������������������������������������������������������������������������������������� 12
Naming the Repository���������������������������������������������������������������������������������������������������������� 13
Add a README File���������������������������������������������������������������������������������������������������������������� 13
Add a .gitignore��������������������������������������������������������������������������������������������������������������������� 14
Choose a License������������������������������������������������������������������������������������������������������������������ 16
Default Branch����������������������������������������������������������������������������������������������������������������������� 17
Git������������������������������������������������������������������������������������������������������������������������������������������������ 19
Clone the Repository to Our Machine����������������������������������������������������������������������������������������� 22
Visual Studio 2022���������������������������������������������������������������������������������������������������������������������� 27
Other Languages������������������������������������������������������������������������������������������������������������������������� 30
Conclusion���������������������������������������������������������������������������������������������������������������������������������� 30

v
Table of Contents

Chapter 3: Creating the Application����������������������������������������������������������������������� 31


Technical Requirements�������������������������������������������������������������������������������������������������������������� 31
A Brief Introduction to Git������������������������������������������������������������������������������������������������������������ 31
Clone������������������������������������������������������������������������������������������������������������������������������������� 32
Pull���������������������������������������������������������������������������������������������������������������������������������������� 32
Commit���������������������������������������������������������������������������������������������������������������������������������� 32
Push��������������������������������������������������������������������������������������������������������������������������������������� 32
Creating the Client Application���������������������������������������������������������������������������������������������������� 33
Exploring the Scaffolded Blazor App������������������������������������������������������������������������������������������� 37
Application Root Folder: Client���������������������������������������������������������������������������������������������� 38
wwwroot Folder�������������������������������������������������������������������������������������������������������������������� 40
Shared Folder������������������������������������������������������������������������������������������������������������������������ 42
Pages Folder�������������������������������������������������������������������������������������������������������������������������� 43
Running the Application�������������������������������������������������������������������������������������������������������� 47
Adding the API Application���������������������������������������������������������������������������������������������������������� 52
Creating the Azure Function Project������������������������������������������������������������������������������������������� 52
Consuming the Function in the Client App���������������������������������������������������������������������������������� 59
Create a Function to Deliver the Weather Forecast��������������������������������������������������������������� 60
Call the Function from the Client Application������������������������������������������������������������������������ 64
Pushing to GitHub����������������������������������������������������������������������������������������������������������������������� 65
Conclusion���������������������������������������������������������������������������������������������������������������������������������� 70

Chapter 4: Creating the Static Web App����������������������������������������������������������������� 73


Technical Requirements�������������������������������������������������������������������������������������������������������������� 73
Create Resource Group��������������������������������������������������������������������������������������������������������������� 73
Create the Static Web App���������������������������������������������������������������������������������������������������������� 78
Base Information������������������������������������������������������������������������������������������������������������������� 81
Logging In to GitHub�������������������������������������������������������������������������������������������������������������� 84
Setup for the Blazor Build������������������������������������������������������������������������������������������������������ 86
Opening the New Resource��������������������������������������������������������������������������������������������������� 90
Overview of the GitHub Workflow����������������������������������������������������������������������������������������������� 91

vi
Table of Contents

Viewing the Deployed Application����������������������������������������������������������������������������������������������� 93


Conclusion���������������������������������������������������������������������������������������������������������������������������������� 95

Chapter 5: Simple Debugging��������������������������������������������������������������������������������� 97


Technical Requirements�������������������������������������������������������������������������������������������������������������� 97
Local vs. Azure Environment������������������������������������������������������������������������������������������������� 97
Visual Studio Debugging������������������������������������������������������������������������������������������������������������� 98
Setting the Port Numbers������������������������������������������������������������������������������������������������������ 98
Changes to the Client Project���������������������������������������������������������������������������������������������� 100
Changes to the Api Project�������������������������������������������������������������������������������������������������� 103
Running the Application������������������������������������������������������������������������������������������������������ 104
Static Web App CLI Debugging�������������������������������������������������������������������������������������������������� 109
Resetting the Code�������������������������������������������������������������������������������������������������������������� 109
The Azure Static Web App CLI���������������������������������������������������������������������������������������������� 110
Running the Static Web App CLI������������������������������������������������������������������������������������������ 112
Debugging the Client Using the CLI������������������������������������������������������������������������������������� 114
Cleaning Up the Breakpoints����������������������������������������������������������������������������������������������������� 115
Save the Changes for the Port Numbers����������������������������������������������������������������������������������� 116
The CLI and Real Azure Resource���������������������������������������������������������������������������������������� 116
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 117

Part II: Creating Our App����������������������������������������������������������������������������� 119


Chapter 6: Retrieving Blog Data��������������������������������������������������������������������������� 121
Technical Requirements������������������������������������������������������������������������������������������������������������ 121
Clean Up������������������������������������������������������������������������������������������������������������������������������������ 121
Api��������������������������������������������������������������������������������������������������������������������������������������� 122
Client����������������������������������������������������������������������������������������������������������������������������������� 122
Creating the Data Source���������������������������������������������������������������������������������������������������������� 124
Azure CosmosDB Free Tier�������������������������������������������������������������������������������������������������� 124
Create the Azure Resource�������������������������������������������������������������������������������������������������� 124
Seed the Table��������������������������������������������������������������������������������������������������������������������� 128

vii
Table of Contents

Blog Post Retrieval�������������������������������������������������������������������������������������������������������������������� 130


Data Model Classes������������������������������������������������������������������������������������������������������������� 130
Retrieving Blog Post Summaries����������������������������������������������������������������������������������������� 132
Retrieving a Single, Full Blog Post��������������������������������������������������������������������������������������� 138
Deploying the Functions������������������������������������������������������������������������������������������������������ 139
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 141

Chapter 7: Displaying Data����������������������������������������������������������������������������������� 143


Technical Requirements������������������������������������������������������������������������������������������������������������ 143
Reading the Summaries������������������������������������������������������������������������������������������������������������ 143
Referencing the Models Project������������������������������������������������������������������������������������������ 144
Create the Service��������������������������������������������������������������������������������������������������������������� 144
Creating the Blog Post Summary Page�������������������������������������������������������������������������������� 147
Display the Whole Summary������������������������������������������������������������������������������������������������ 151
Displaying the Whole Blog Post������������������������������������������������������������������������������������������������ 154
Reading the Blog Post��������������������������������������������������������������������������������������������������������� 155
Display Blog Post����������������������������������������������������������������������������������������������������������������� 157
Add the First Blog Post to the Index Page��������������������������������������������������������������������������������� 160
Prepare the Index.razor File������������������������������������������������������������������������������������������������ 160
Create the BlogPostSummary Component�������������������������������������������������������������������������� 162
Change the Blog Post Summary Page��������������������������������������������������������������������������������� 164
Checking Our Results���������������������������������������������������������������������������������������������������������������� 165
Running Locally������������������������������������������������������������������������������������������������������������������� 165
Deploy Blog Post������������������������������������������������������������������������������������������������������������������ 167
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 168

Chapter 8: Static Web App Configuration������������������������������������������������������������� 169


Technical Requirements������������������������������������������������������������������������������������������������������������ 169
Creating the staticwebapp.config.json File������������������������������������������������������������������������������� 170
Navigation Fallback������������������������������������������������������������������������������������������������������������������� 171
Routes��������������������������������������������������������������������������������������������������������������������������������������� 175
Restricting Access to Resources����������������������������������������������������������������������������������������� 177

viii
Table of Contents

Protecting Resources���������������������������������������������������������������������������������������������������������� 177


Moving Resources – Temporarily���������������������������������������������������������������������������������������� 179
Moving Resources – Permanently��������������������������������������������������������������������������������������� 179
Response Overrides������������������������������������������������������������������������������������������������������������������ 180
Example Configuration�������������������������������������������������������������������������������������������������������������� 180
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 182

Part III: Authentication������������������������������������������������������������������������������� 183


Chapter 9: Authentication������������������������������������������������������������������������������������� 185
Technical Requirements������������������������������������������������������������������������������������������������������������ 185
Authentication Basics��������������������������������������������������������������������������������������������������������������� 185
Standard Authentication����������������������������������������������������������������������������������������������������������� 186
ClientPrincipal��������������������������������������������������������������������������������������������������������������������� 189
Accessing Authentication Data in Our Application��������������������������������������������������������������� 190
Adding API Authentication��������������������������������������������������������������������������������������������������� 190
Client-Side Authentication��������������������������������������������������������������������������������������������������� 194
Login Screen������������������������������������������������������������������������������������������������������������������������ 203
Role-Based Access�������������������������������������������������������������������������������������������������������������� 206
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 210

Chapter 10: Creating Blog Posts��������������������������������������������������������������������������� 211


Technical Requirements������������������������������������������������������������������������������������������������������������ 211
Adding the Azure Functions������������������������������������������������������������������������������������������������� 211
Creating Blog Posts with the POST Method������������������������������������������������������������������������������ 212
Updating Blog Posts with the PUT HTTP Method����������������������������������������������������������������� 215
Deleting Blog Posts with the DELETE HTTP Method������������������������������������������������������������ 217
Securing the Functions�������������������������������������������������������������������������������������������������������� 219
Updating the Blog Post Services����������������������������������������������������������������������������������������� 220
Creating Blog Posts������������������������������������������������������������������������������������������������������������� 220
Updating Blog Posts������������������������������������������������������������������������������������������������������������ 225
Deleting Blog Posts������������������������������������������������������������������������������������������������������������� 227
Adding the Blog Post Edit Page������������������������������������������������������������������������������������������������� 229

ix
Table of Contents

Adding the Create Link�������������������������������������������������������������������������������������������������������� 236


Adding the Edit and Delete Links����������������������������������������������������������������������������������������� 236
Deploy and Test������������������������������������������������������������������������������������������������������������������� 237
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 239

Part IV: SWA Functionality�������������������������������������������������������������������������� 241


Chapter 11: Static Web App CLI���������������������������������������������������������������������������� 243
Technical Requirements������������������������������������������������������������������������������������������������������������ 243
Running the Application������������������������������������������������������������������������������������������������������������ 243
Changing Port Numbers������������������������������������������������������������������������������������������������������������ 246
Azure Function Port Numbers���������������������������������������������������������������������������������������������� 246
Changing the Static Web App CLI Default Port�������������������������������������������������������������������� 247
Changing the Client Port������������������������������������������������������������������������������������������������������ 247
Running Static Content������������������������������������������������������������������������������������������������������������� 248
Publish the Client Project���������������������������������������������������������������������������������������������������� 248
Run the Static Web App CLI with Static Files����������������������������������������������������������������������� 249
Extending the .gitignore File������������������������������������������������������������������������������������������������ 250
Static Web App CLI Configuration���������������������������������������������������������������������������������������� 251
Commit Our Changes���������������������������������������������������������������������������������������������������������������� 255
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 255

Chapter 12: Testing in Azure�������������������������������������������������������������������������������� 257


Technical Requirements������������������������������������������������������������������������������������������������������������ 257
Azure Static Web App Staging Slots������������������������������������������������������������������������������������������ 257
Making a Branch����������������������������������������������������������������������������������������������������������������������� 259
Creating the Staging Slot���������������������������������������������������������������������������������������������������������� 260
Testing in the Cloud������������������������������������������������������������������������������������������������������������������ 262
Making a Second Change��������������������������������������������������������������������������������������������������������� 263
Revisiting the Stage Environment��������������������������������������������������������������������������������������������� 263
Staging Environment Settings�������������������������������������������������������������������������������������������������� 264
Staging Environment Limitations���������������������������������������������������������������������������������������������� 265
Free Tier������������������������������������������������������������������������������������������������������������������������������ 266

x
Table of Contents

Removing Staging Environments���������������������������������������������������������������������������������������������� 266


Automatically Cleaning Staging Environments�������������������������������������������������������������������� 267
Manually Cleaning Up Environments����������������������������������������������������������������������������������� 269
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 269

Chapter 13: Custom Domains������������������������������������������������������������������������������� 271


Technical Requirements������������������������������������������������������������������������������������������������������������ 271
Adding a Custom Domain���������������������������������������������������������������������������������������������������������� 272
What Domains to Add���������������������������������������������������������������������������������������������������������� 272
Azure Portal Custom Domain Pane�������������������������������������������������������������������������������������� 273
Self-Managed Domain��������������������������������������������������������������������������������������������������������� 274
Domain on Azure DNS��������������������������������������������������������������������������������������������������������� 276
Azure-Generated URL���������������������������������������������������������������������������������������������������������������� 277
Conclusion�������������������������������������������������������������������������������������������������������������������������������� 278

Appendix A: Next Steps���������������������������������������������������������������������������������������� 279


Add User Details������������������������������������������������������������������������������������������������������������������������ 279
Blog Post Summary Refresh����������������������������������������������������������������������������������������������������� 279
S
 earch��������������������������������������������������������������������������������������������������������������������������������������� 280
Custom Summary Length��������������������������������������������������������������������������������������������������������� 280
Preview Complete Flag������������������������������������������������������������������������������������������������������������� 280
T ag Lookup�������������������������������������������������������������������������������������������������������������������������������� 281
Blog Post Preview��������������������������������������������������������������������������������������������������������������������� 281
Make the Application Multiauthor��������������������������������������������������������������������������������������������� 281
Fully Implement Post Status����������������������������������������������������������������������������������������������������� 281
S
 tyling��������������������������������������������������������������������������������������������������������������������������������������� 282

Appendix B: Changing the GitHub Workflow��������������������������������������������������������� 283


Opening the Workflow File�������������������������������������������������������������������������������������������������������� 283

Index��������������������������������������������������������������������������������������������������������������������� 285

xi
About the Author
Speaker, author, and software developer, Stacy Cashmore
has been developing solutions since the mid-1990s in
various companies and industries ranging from facilitating
contract jobbing to allowing consumers to close a mortgage
without the help of a financial adviser – with lots in between.
She has a passion for sharing knowledge: using story telling
for sharing her experiences to help teams grow in the ways that
they develop software and work together and performing live
coding demonstrations to inspire others to try new technologies.
For her effort in the community, Stacy has been awarded the Microsoft MVP for
Developer Technologies since 2020.

xiii
About the Technical Reviewers
Marc Duiker is a Senior Developer Advocate at Ably with a
strong focus on event-driven architectures in the Azure cloud.
He loves helping developers to achieve more every day.
You might have seen Marc at a developer meetup
or conference since he's a regular speaker in the area of
Azure cloud and serverless technologies. He started Azure
Functions University, a free and open source learning
curriculum on GitHub, where everyone can learn about
Azure Functions at their own pace. In 2019, 2020, and
2021, Marc received the Microsoft Azure MVP award for his
community contributions.
In his spare time, Marc likes to give attention to the creative part of his brain. He likes
to create pixel art (check out VSCode Pets), code visuals and music, and an occasional
retro game.

Jimmy Engström has been developing ever since he was


seven years old and got his first computer. He loves to be on
the cutting edge of technology, trying new things. When he
got wind of Blazor, he immediately realized the potential and
adopted it already when it was in beta. He has been running
Blazor in production since it was launched by Microsoft.
He is the author of Web Development with Blazor and the
co-host of Coding After Work (podcast and stream).
His passion for the .NET industry and community has
taken him around the world, speaking about development.
Microsoft has recognized this passion by awarding him the Microsoft Most Valuable
Professional award nine years in a row.

xv
Acknowledgments
This book has been a while in the making. Not only the writing itself but also the journey
leading up to it. And there are many people to whom I owe a huge thank you.
I need to start with the amazing Jessica Engström. For your kindness to a terrified
conference attendee and starting me on this journey by convincing me to try my hand at
public speaking and for becoming an amazing friend.
To all the speakers from Swetugg 2019 for helping me get through that first talk, I’m
honored that I can call so many of you friends now.
And to Mattias Karlsson, for inviting me to write my first technical talk for your
conference in 2020. That really put me on the road to making technical content and
looking at new technologies – even if Covid got in the way and it had to be delivered
virtually! I’d still love to give a technical talk for your user group/conference at
some point.
To Cindy Velthuizen and Tom Ehren, for your support, advice, and time over the last
few years as I made this journey.
A huge thanks to Jonathan Gennick for reaching out, asking me if I would be
interested in writing a book, and helping me through those first stages.
To Shrikant Vishwakarma and Smriti Srivastava for your help while actually writing
the book and keeping me on track.
And everyone else at Apress who make getting books from Word documents on my
computer to being an actual book possible.
To my technical reviewers.
Marc Duiker for checking that I was doing the right things with the Azure Functions
through the chapters, and laughter at some of the comments I made.
And Jimmy Engström for doing the same with the Blazor code and helping me think
my way out of problems during the writing.
Of course, any issues that remain here are entirely down to me!
And to everyone else, too numerous to mention, who have helped me get this book
into readers’ hands.

xvii
Acknowledgments

Finally, my parents for always supporting me in what I wanted, and needed to do,
and cheering me on when it would have been so easy to give up at school, college, and
university. It means the world to me that you believed in me through those years.
And my partner and child, who wish to remain anonymous, but it wouldn’t be right
to not include them here. For your love, support, and helping me stay on track, I am
forever indebted.

xviii
CHAPTER 1

Introduction
A couple of years ago, I decided that I’d been putting off making my own website for too
long. With the technology available to us, it doesn’t need to be difficult or complex to
develop our own space on the Web. I didn’t want to run my site on a simple home page
application though, I wanted to experiment with new technologies and learn new things!
With this in mind, I have used Azure Static Web Apps, with Blazor and .NET Azure
functions, to develop my personal site over the last couple of years.
I’ve spoken at many conferences and meetups about the subject, and when I hear
that someone has taken what I’ve said and tried something by themselves, it gives me a
real buzz of excitement that I’ve helped someone take that step.
And so, I decided to write this book to take a beginner on their journey of discovery!
Before we get started though, a little background on the technology that we’ll
be using!

JamStack
A method of developing applications that is becoming ever more popular is JamStack.
That is, using markup files and JavaScript to make a dynamic application that runs in a
browser and then supplementing these with APIs to fetch and store data.
Splitting up our applications in this way allows us to take advantage of new ways
of hosting sites. Our application is made of static files, so we no longer need a complex
web server. We can simply host our files statically so that they can run inside of a user’s
browser.
As our back end now only serves data requests, rather than complete web pages,
we can use the growing number of serverless possibilities to host our API, allowing easy
deployment and scaling using technologies like Microsoft Azure Functions, Google
Cloud Functions, or AWS Lambda Functions.

3
© Stacy Cashmore 2022
S. Cashmore, Beginning Azure Static Web Apps, https://doi.org/10.1007/978-1-4842-8146-8_1
Chapter 1 Introduction

When we put this together, we get a hosting model that is simple and cheap – even
free – to put our application out into the world!
Over the last few years, this way of creating applications has been increasing in
popularity over traditional server-side generated applications that require dedicated web
servers to serve content.

BlamStack
JamStack is great for developers who use JavaScript technologies.
But there are lots of developers and development teams that use .NET with C#. Until
now, the JamStack way of developing applications was closed to these developers. Front-
end development in .NET was restricted to Web Forms or MVC. Both technologies have
their place – but both are also server technologies, with the final HTML being served to
the browser.
Then Blazor arrived! Originally released as a server technology, but with a browser
technology released soon after – Blazor WebAssembly – allowing us to take advantage of
using static files for our application.
Blazor WebAssembly runs on a .NET runtime compiled to run inside of a browser.
Not using any special plug-ins – this isn’t Silverlight for the 2020s – but using the built-in
WebAssembly runtime in the browsers themselves.
Blazor WebAssembly applications run the same way as JamStack applications. The
Blazor application handles the client application, running on the machine of the user
themselves, while an API provides the data to make the application dynamic. JamStack
but with Blazor: BlamStack!
Now we can take advantage of the paradigm using C# and .NET.

Azure Static Web Apps


To deploy either a JamStack or BlamStack application, there are a few components that
we need to have available:

• The static file hosting for the front-end application


• Serverless functions for the API

• Routing components to connect the API securely to the front end

4
Chapter 1 Introduction

There are several ways to do this and with multiple providers. In 2021, Microsoft
introduced Azure Static Web Apps to make this possible in Azure.
Rather than deal with each of the components that make our application separately,
Azure Static Web Apps contain components all in one easy-to-manage resource.
The Azure Static Web App handles the global distribution of the static content and
even handles cache invalidation when a new version of the application is deployed.
They also have built-in Azure Functions to handle the API for our application.
Not only does this mean that we only need one Azure resource to handle storage,
distribution, and our Azure Functions, etc., but it also connects the static content to
those Azure Functions so that, to the outside world, it seems like it is one single resource.
This, again, simplifies our workflow by ensuring that we do not need to handle CORS
requests between the front end and back end.
And to make life even easier for us, we even get authentication out of the box with
several popular platforms, meaning that we can authenticate our users without ever
knowing their passwords!
If deploying from GitHub or Azure DevOps, we even get a simple continuous
integration and delivery (CI/CD) flow created at the same time as our application. The
fact that this works out of the box means that anyone can have a
high-quality CI/CD flow without having to invest time learning how to use those
pipelines, allowing for greater focus on the application itself!
It doesn’t mean that we are limited in our options though! As developers, we can take
more control over our Azure Static Web App if we need to, making it also suitable for the
enterprise environment.

Book Focus
On our journey through this book, we will be focusing on getting started with Azure
Static Web Apps, looking at what we can do to get an application into production, with
authentication.
At the end of our journey, I’ll leave you with some suggestions for you to carry on
your project after you have finished and allow yourself to learn even more.
The book is focused on a Windows development environment; it is possible to follow
along on any platform that supports .NET development – though some software will be
different to the descriptions in the books.

5
Chapter 1 Introduction

Let’s Get Started!


So, without further ado, let’s get started with our journey! Before we can start with the
actual code, we’ll need to make sure that we have the correct accounts and software
installed.
This will be the focus of Chapter 2. In Chapter 3, we’ll start with the
development itself!

6
CHAPTER 2

Setting
Up the Environment
In this chapter, we will set up our development environment and required online
services so that we can create our first Azure Static Web App.
We will create the online accounts and repositories needed to host our Static Web
App and source code, clone the repo to our local machine, and install Visual Studio 2022
as an IDE to develop our applications locally. We can use any edition of Visual Studio for
the examples in this book, including the free Community Edition.
By the end of this chapter, we will have everything that we need, both online
accounts and resources on our local machine, to be ready to create and deploy our Azure
Static Web App.

• Create a Microsoft Account and Azure Subscription.

• Create a GitHub account.

• Create our GitHub repository.


• Install Git on our development machine.

• Clone the repository to our local machine.

• Install Visual Studio 2022 Community Edition for development.

If you already have all the required accounts and tools already installed and are
experienced in creating repositories in GitHub, then feel free to simply create a new
repository, clone it to your machine, and skip ahead to the next chapter!

7
© Stacy Cashmore 2022
S. Cashmore, Beginning Azure Static Web Apps, https://doi.org/10.1007/978-1-4842-8146-8_2
Chapter 2 Setting Up the Environment

Microsoft Account and Azure Subscription


Firstly, we are going to need an Azure Subscription. Without a subscription, we will not
be able to create the Azure Static Web App needed to deploy our application.
If you already have an active Azure Subscription, then proceed to the section
“GitHub Account.”
To create an Azure Subscription, you will also need a Microsoft Account – if you do
not have one of these already, then we can create one during the process of creating an
Azure Subscription.
When creating your first Azure Subscription, you receive a number of benefits, some
for the first month, others for the first year.
For the first month, the most important is the free Azure credits – with a value of
$200 at the time of writing. This credit has two advantages for our first steps into the
world of Microsoft Azure. Not only does it allow us the freedom to experiment with
different resources that could otherwise have a cost associated with them, it also acts as a
spending limit for that first month to protect us from provisioning resources accidentally.
To create the Azure Subscription, go to https://azure.microsoft.com/en-us/ and
click the “Try Azure for free” button, seen in Figure 2-1.

Figure 2-1. Microsoft Azure Information Website

8
Chapter 2 Setting Up the Environment

This will bring us to the Microsoft Azure free trial screen. Click the green “Get started
for free” button as seen in Figure 2-2.

Figure 2-2. Microsoft Azure Free Trial Screen

A prompt will appear to log in to a Microsoft Account. If you do not already have an
account, you can create one instead.
In the course of this flow, you will need to enter a credit card as a payment method for
the subscription.
The flow to create the Azure Account asks for standard personal data (name, email,
phone, address, etc.).
When the portal is visible, the account is set up and ready.

GitHub Account
Next, we need to set up a GitHub account. This will be where our code repository lives
and will be used to deploy our Static Web Application into Azure.

1. Go to https://github.com.

2. Click the “Sign up” button.

3. In the page that opens up, enter the email and click “Continue.”

4. Enter an email and click “Continue.”

9
Chapter 2 Setting Up the Environment

5. Enter a strong password.

If the password is not strong enough, or is possibly compromised,


then a message will be displayed on the page.

Click “Continue.”

6. Enter whether or not you would like to receive marketing mails


and click “Continue.”

The completed page will look something like Figure 2-3.

Figure 2-3. GitHub Signup Page 1

After completing the puzzle, GitHub will send an email with a code. This must be
entered on the form seen in Figure 2-4 to prove that we have access to the email address
we used.

10
Chapter 2 Setting Up the Environment

7. Enter the code to continue the process.

Figure 2-4. GitHub Email Verification Code Entry

Now the email has been verified, we can continue to set up our account!

8. Click “Just me” for the team size.

9. If you are a student or teacher, fill the information in; otherwise,


leave the “Are you a student or teacher?” question empty.

10. Click “Continue.”

11. We can ignore the feature selection screen for the purpose of
this book.

Click “Continue.”

12. Finally, we need to select the payment plan.

Click “Continue for free.”

After selecting a plan, we will be redirected to our new GitHub dashboard as shown
in Figure 2-5.

11
Chapter 2 Setting Up the Environment

Figure 2-5. GitHub Dashboard

GitHub Repo
Now that we have a GitHub account, we will need to create a repository to hold our code
and from where we will be building and deploying our Azure Static Web App.
From the GitHub dashboard at the end of the last session, click “Create repository”
as shown in Figure 2-6.

Figure 2-6. GitHub Create Repository Button

This will open the screen where we enter the information needed to create a
repository.

12
Chapter 2 Setting Up the Environment

When creating a repository, it’s important to check that the owner of the repository is
set correctly. It should be correct by default, but it is always good to make sure!
Beyond this, there are a number of steps that we need to take to ensure that our
repository behaves as expected.

Naming the Repository


Enter a name for the repository; we can use whatever name we like, as long as it is
unique for the owner.
A suggestion to follow along with this book would be
“beginning-static-web-apps”
Entering a description is optional, and for now we can leave this blank. Having a
good description is important however, and we can add it later.
We need to decide whether or not we would like our repository to be open for the
world to see. There are advantages to having a repository marked as public. To see an
overview of these, go to https://github.com/pricing.
There are also other advantages outside of GitHub to public repositories. They
can allow us to build a public portfolio of work, to show how we develop software, for
example.
Of course, there are also downsides; if we have a public repository and there is
sensitive information accidentally pushed to it, then we have to assume that information
is compromised and take the steps needed to protect ourselves. Though even with
a private repository, we should still take care not to commit anything that could
compromise our security!
To ensure that we are seeing the same behavior when accessing our repository as we
see in the book, set the visibility to “private” for now. It is always possible to change the
visibility at a later date.
Lastly, there are three options that we can set to initialize the repository.

Add a README File


A README file is a Markdown document explaining the purpose of the repository. This
is the first documentation that people will see if our repository is public and people visit.
It is displayed by default in GitHub when it exists on the home page.

13
Chapter 2 Setting Up the Environment

README files are often used to convey the purpose of a repository, how to use
the application, how to set up and run the application for development, and any extra
information that could be useful.

Add a .gitignore
When creating software, many files get created which should only exist on the developer
machine where they are created. Visual Studio, for example, creates files to hold user
information, along with “bin” and “obj” files when code is built. These files do not need
version control. Also, there are files which may contain secrets, local settings files, for
instance, that we need to run code locally. These should never be pushed to a repository
for security reasons.
Depending on the development language, and environment, that is used, different
patterns of files should be ignored.
For this book, Visual Studio 2022 is going to be used, so we need a .gitignore tailored
to that environment.
Open the drop-down box as seen in Figure 2-7.

14
Chapter 2 Setting Up the Environment

Figure 2-7. .gitignore Selection List

As there are many options available, it is generally quicker and easier to filter the
options than to search through the whole list.
Type “Visual” into the filter box, and the list will be more specific as seen in
Figure 2-8.

15
Chapter 2 Setting Up the Environment

Figure 2-8. .gitignore Filtered List

Select “VisualStudio.”

Choose a License
The last option is for the license used for the repository. This isn’t mandatory, but if we
are making a repository public, then consider adding a license to it. When we do this, it
will be displayed at the top of the repository when people visit the page.
This book does not cover what license models are best – that is a choice that the
repository owner needs to make. However, there are resources online that can help make
the selection. For further reading, follow the following links:
https://docs.github.com/en/repositories/managing-our-repositorys-
settings-and-features/customizing-our-repository/licensing-a-repository
https://choosealicense.com/
If a license is needed, select the required license from the list shown in Figure 2-9.

16
Chapter 2 Setting Up the Environment

Figure 2-9. GitHub Repository License List

As with the .gitignore, we can filter the list of options to find our preferred license.

Default Branch
When the README, .gitignore, or license option is checked, GitHub will initialize
the repository with a default branch in order to store those files. Extra information is
displayed on the page about the default branch as seen in Figure 2-10.

Figure 2-10. GitHub Default Branch Explanation

Now that all options are selected, the “Create New Repository” page should look
something like Figure 2-11.

17
Another Random Document on
Scribd Without Any Related Topics
Suomen, Ahvenanmaan ja monta paikkaa Ruotsissa läänitykseksi,
mutta täytyi heittää vallikan Kuninkaalle, joka kruunattiin vielä
samana vuonna 1497. Steeni Stuure sai kuitenki vielä olla yksi
neljästä Ruosia hallitsevasta Riiki-Raatista. Mutta pian vaikuttivat
vihamiehet, että hänen täytyi lahjoituksistansa antaa Turun, Hämeen
ja Savon linnat sekä läänit takasin Kuninkaalle.

Maunus III Stiernkorssista, joka nyt oli ollut pispana, ei löydy paljo
muuta mainittuna, kun että häntä kiitetään, että hänellä oli Kirkon
puolta pitäissänsä paljo vastuksia ja mielikarvaita, ja että hän oli
laittanut Dekaanin arvon Tuomiokirkolla, sekä muutenki pappivirkain
tuloja lisäillyt. Myös tietään hänen toimittaneen yhteisen
atrioitsemisen säätyveljillensä ja muillenki köyhille Turussa. Sammui
v. 1500.

Tämän perästä tulee Laurentius Mikhaelinpoika Suurpää pispaksi.


Hän oli kotosin Turusta ja Pariisis-Maisteri. Vihittiin vasta vuoden
perästä, Upsalassa, saatuhun arvoonsa. Hänen aikana tapahtui, että
Herrat Ruotsissa luopuivat jällensä pois Kuningas Johannista ja
valitsivat v. 1501 Steeni Stuure Vanhemman uudellensa
Riikihoitajaksi. Silloin oli Suomessa Danskalainen mies, Maunus
Frille, joka piti Johanin puolta, eikä tahtonut Steeni Stuuren ystäville
antaa Turun linnaa. Mutta ne piirittivät sitä yli kolme kuukautta, jonka
perästä linna, Saksalaisen vartoväen petoksesta, joka tahtoi saada
käsiinsä muutaman siellä löytyvän suuren rahasumman, annettiin,
6:tena p. Syyskuuta v. 1502, Steeni Stuurelle. Muu osa maata taisi
vastustelematta häneen luopua. Riikihoitajalla oli vielä taistelemista
Danskalaisia vastaan ja kuoli v. 1503, myrkystä niinkuin sanotaan.
Vaikka Danskan Kuningas nyt tahtoi saada Ruotsin valtaansa, niin
valittiin kuitenki, Hemminki Gadin nerosta, Svantte Stuure
Riikihoitajaksi seuraavana vuotena. — Samana v. 1504 tehtiin
sotilakko Venäjän kanssa 20:neksi ajastajaksi, josta on nähtävä, että
sotatila oli kestänyt aina siihen saakka, vaikk'ei siitä ole tietoja, ja se
mahtoi olla huokiampi Suomelle loppupuolellaan, Venälaisten sodan
tähden Livon Ritariseuran ja Lithovian kanssa. Suuri Venäläissota oli
siis pitkittänyt 14 vuotta. — Nyt seuraavat rasitukset Danskalaisilta.

Pispa Laurentius Suurpään aikana jaettiin, varsinki Karjalassa ja


Savossa, jossa pitäjät olivat niin laajat, että oli muutamilla 15
penikuormaa ja enempiki kirkolle, seurakuntia pienemmiksi; ja
muutamassa Tukhulmin Riikikokouksessa päätettiin uutten kirkkojen
rakentamista isänmaassamme. Tämä pispa tuli, visiteerinki
matkallansa Ahvenanmaahan, yhtäkkiä halvatuksi ja kuoli muutaman
ajan perästä v. 1506. Sittä valittiin Johannes IV Olavinpoika, hänki
Suomalainen syntymältänsä ja Pariisis-Maisteri opiltaan,
jälkeenseuraavaksi pispaksi ja vihittiin vasta seuraavana vuotena
Upsalassa, saatua ennen Paavilta vahvistuksen vaaliinsa. Hänen
täytyi ostamalla saada Kuusiston linna edellisen pispan väeltä, jotka
eivät mielineet sitä antaa, ennenkun saivat 200 markkaa.

Riikihoitaja Svantte Stuure oli erityistä (nimittäin Natt- och- Daagin)


sukua, kun Steeni Stuure Vanhempi oli ollut, ja hänen aikana
tapahtui alituisia kapinoita Danskalaisten kanssa. Hänell'oli auttajana
ja ystävänä Hemminki Gaddi, mies hengellisestä säädystä, mutta
useimmin tavattu sota- ja hallitusasioista, kun alttarilla, ja palava
vihasta Danskan nimeen. Mutta isoin osa Raatista ja melkein kaikki
pispat olivat Danskan puolella ja aikoivat aina kutsua Kuningas
Johania takasin, jota Svantte ja Hemminki estivät. Kun nämät
viimmeksi mainitut miehet vielä saivat Hansaseuran puolellensa, niin
alkoivat he Danmarkkia kovemmasti hätyyttää ja kostaa sen
hävitäntäretkiä Suomeen. Danskalaiset olivat nimittäin rosvoneet ja
hävittäneet Suomen rantamaita v. 1509. Saman vuoden 2 p.
Elokuuta, kun kaikki Turun asukkaat nukkuivat unen levossa, tuli
sydänyöllä yhtäkkiä Otto Ruuthi Danskalaisten kanssa suurella
rymäkällä ynnä torvein ja sotasoitinten pauhinalla kaupunkiin, ja
alkoivat ryöstää ja murhata hirviästi. Tuomiokirkosta ryöstettiin kaikki
kirjat, korennukset ja irtain omaisuus; samoin yksinäistenki
huoneista. Ryöstötavara kannettiin Danskalaisten laivoille.
Yläisemmistä murhattiin monta, ja toinen osa vietiin vankina
Danmarkkiin. Nämät voret viipyivät vielä muutaman ajan Turussa,
pitkittäin ilkiätä työtänsä. Vuotena perästä oli myös Amiraali Severini
Norbyy liikkeellä ja otti Kastelholman linnan Ahvenanmaalla, tehden
linnanhaltian frouanensa vankiksi.

Arvidi Kurkki valittiin pispaksi, kun Johannes Olavinpoika,


palattuansa visiteeringiltä Karjalassa, oli v. 1510 kuollut suuresta
ruokapalasta, joka hänellä oli kurkkuun tarttunut ja hänen
läkähyttänyt. Arvidi oli ulkomaalla tullut Maisteriksi ja ollut Dekaanus
Turussa, valittuansa pispaksi lähtenyt Italiaan saamahan Paavilta
vahvistuksen vaaliinsa, ja vihittiin vuoden kuluttua Strengnääsissä.
Isänmaansa hyvää tarkoittava mies oli tämä pispa. Hänen
valintavuotena, elikkä Venäjän tietoja myöten vasta 9:tenä
Toukokuuta v. 1513, pitennettiin se vähää ennen 20:nesi vuodeksi
sovittu sotilakko, Novgorodissa 60:neksi ajastajaksi, samoilla
ehdoilla kun Pähkinäsaaren rauhassa Maunus Liehakon aikana.

Mutta Riikihoitaja Svantte Stuure oli kuollut pikaisesti v. 1512 ja


Ruotsin kansa siaan valinnut hänen pojan, Steeni Stuure
Nuoremman, riikiä hoitamaan ja vartioimaan, ehkä Raati ja ylimykset
tahtoivat siihen virkaan Erikki Trollea. Danmarkin Kuningas Johani II
oli myös kuollut v. 1513, ja poikansa Kristiani II, Tyranno
(Hirmuvaltia) ansaitulla liikanimellä, tullut hallitukseen. Hän oli jo
isänsä eläissä tullut Ruotsissa otetuksi kruunun perilliseksi, ja kun ei
hän heti päässyt siihen arvoon, niin sanotaan hänen, samalla tavoin
kun isänsä ennen, yllyttäneen Venäläisiä Suomehen karkaamaan.
Vuonna 1515, ja kahtena sitä seuraavana, mainitaanki Venäläisen
hävittäneen Suomea eli Norbotnia, jolloin siis vasta käyty sotilakko
heti rikottiin. Sota oli myös v. 1516 noussut Steeni Stuuren ja
Danskan välillä, Pääpispan Gustavi Trollen juonilla, joka viimmen tuli
arvonsa menettämään ja hänen auttaja, Kristiani, voitettiin
Bränkyrkan tappelussa, lähellä Tukhulmia, v. 1518. Nyt asetettiin
Paavin käskystä hengellinen oikeus Danmarkissa, ratkasemaan
virastansa lasketun Pääpispan kanteita Riikihoitajata vasten, ja
Steeni Stuure kaikkine puoltajinensa tuomittiin pannaan. Siitä rupesi
Kristiani sotajoukkoa kokoamahan, joka v. 1520 lähti Ruotsia
kurittamaan. Boogesundin tykönä tuli tappelu, jossa Steeni Stuure
Nuorempi voitettiin, ja kuoli muutaman ajan perästä haavoistansa.
Riikihoitajan kuoltua tuli hämmästys Ruotsin kansaan, eikä kukaan
tiennyt mitä nyt oli tehtävänä, kun Danskalainen miekalla ja tulella
läheni pääkaupunkia. Ainoastaan Steeni Stuuren leski, se rohkia
Kristiina Gyllenstierna, piti uskalluksensa tallella ja puolti Tukhulmia,
joka Kristianilta piiritettiin, vaikka jo oliki suuri osa Ruotsin Herroja
tunnustanut Kristiania Kuninkaaksensa. Mutta kun Hemminki
Gaddiki nyt meni Danskalaisen puolelle ja houkutteli Kristiinata
samaan, niin antoi viimmen tämä vaimo (7:tenä Syyskuuta)
Tukhulmin Kristianille, joka hänelle lupasi antaa omaisuudeksi
Hämeenlinnan ja sen läänin ynnä Kokemäen kartanon. Myös
luvattiin Ruotsalaisille kaikkinainen rauha, sekä Kristiinan ystäville ja
puoltajille Suomessa, joiden seassa nimitetään pispa Arvidi Kurkki,
Ooke Jöranssoni Totti, Tönnes Erikssoni Totti ja Niilo Eskilssoni
Baneeri, täysi vapaus kaikesta rangaistuksesta ja vainosta. Mutta
pian näytti Kristiani, mitä hänelle oli mielessä ja mitenkä hän aikoi
lupauksiansa täyttää. Luvattuja omaisuuksia ei annettu Kristiinalle.
Marraskuussa 8:tena päivänä, kun uuden Kuninkaan kruunaamisen
juhlaa pidettiin Tukhulmissa, suljettihin portit Tukhulmin linnaan,
jossa tiettävästi nyt löytyi paljo kansaa, ja muutamain
edelläkäyneitten syyttämisten perästä ruvettiin mestaamaan kaikkia,
kun ei luultu olevan Danskan ystäviä, ei ainoastaan Herroja, vaan
myös muita läsnäolevaisia alhaisempia, ilman armoa ja oikeutta.
Olaus Magnus, joka on kirjoittanut kirjan Pohjaisten Kansain elosta,
jossa Suomestaki tulee paljo puhumaan, näki omilla silmillään 94
ihmistä mestattavan. Toisia hirtettiin eli piinattiin kuoliaaksi. Tämä on
se mainio Tukhulmin verilöyly. Mutta tulipa Suomellenki vuoronsa.
Heti Ruotsiin tultuansa oli Kristiani lähettänyt käskyjä sen maan
Herroille, tulemahan Ruotsiin riikin asioista keskustelemaan. Mutta
lienevätkö Herrat jotaki petosta aavistaneet, slllä ei heistä yksikään
käskyä totellut. Sittä oli Kristiani lähettänyt Hemminki Gadin
sotajoukolla, Suomen maata kukistamaan ja sen linnoja ottamaan.
Linnat antausivat hänelle vastustelematta, sillä ei arveltu vastuksen
enää mitään auttavan; entiset linnanhaltiat laskettiin viroistansa,
joihin Saksalaisia ja Danskalaisia miehiä pantiin. Turun linnaan
asetettiin vasta mainittava Thuomas Volffi. Mutta nyt tuli Kristianilta
verinen käsky, jota myöten Ooke Jöranssoni Totti mestattiin
Hämeenlinnan ulkopuolella (27 Marrask.). Hemminki Gaddi sai myös
vanhoilla päivillään havaita, miten Kristianin laatuiset miehet
palkitsevat ystäviänsä; sillä hän ja Niilo Eskilssoni Baneeri mestattiin
Raaseporin etuloilla (16 Jouluk.) Pispa Arvidi säilytti henkensä; joko
hän lie Kuusiston linnassa saanut turvansa, eli muuten tiennyt paeta
vainojiansa. Sillä keinoin menetteli Kristiani Ruotsissa, ja yli 600
ihmistä oli hengeti nutistettu, kun hän seuraavan vuoden alulla palasi
Danmarkkiin.

Kun nämät kauhistukset paraaltaan tapahtuivat Ruotsissa,


tavatahan Gustavi Erikssoni Vaase, karattuansa vankeudesta
Danmarkissa Lybekkiin ja sieltä lähettyänsä Ruotsiin, eräilemässä
Danskalaisten pelvon tähden Daalarein metsissä, puimassa
talonpoikain riihissä, piiloutuneena vainojiltansa muin
heinäkuormassa, muin kaatuneitten puitten alla, muin kuopissa ja
kellareissa: hän se nuori aatelismies, jonka rehellisessä sydämessä
ajatukset Ruotsin vapauttamisesta olivat nousseet, ja jonka aikeensa
hän nyt tulee, niinkuin hänellä oli itsellänsä tapana sanoa, "Jumalan
ja Ruotsin talonpoikain kautta" täyttämäänki. Hän sai Daalarilaiset ja
sen perästä talonpojat muillaki paikoilla puolellensa, sittä
vapasukusia Herrojakin; piiritti Tukhulmia, jossa kaupungissa
Magistraati pyysi Suomesta avuksensa miehiä ja sotitarpeita; ja
valittiin Syyskuussa v. 1521 Herrainpäivillä Vadstenassa,
Riikihoitajaksi. Nyt alkoi hän Suomenki vapauttamista miettiä; lähetti
sinne Niilo Arvissoni Vestgööthen ja Henrikki Jönssonin Haagasta,
sotamiesjoukon kanssa, ja näihin yhdistyy Niilo Monssoni Grabbe
Grabbakasta ynnä monta muuta vapasukuista Suomalaista. Nämät
miehet alkoivat 24 Marraskuuta piirittää Turun linnaa, jossa Thuomas
Volffi oli haltiana, ja löytyi hänellä siellä paljo vartoväkeä sekä
runsaasti sotitarpeita. Siihen siaan oli piirittäjillä sota-aseista ja
ruutista suuri puutet, jota pispa Arvidi ainaki koki heille varustaa.
Vaan ei tahtonut piiritystyö Ruotsalaisilla menestyä. Eräällä
karkauskerralla otettiin muutamia Ruotsalaisista, joiden seassa Niilo
Arvidssonin veli Bengti vangiksi. Volffi antoi hirttää kaikki tyyni
linnanmuurin ulkopuolella. — Ahvenanmaahan lähetti Gustavi
Hemminki von Brokkenhuusin, ottamaan Kastelholman linnaa, jota
Lyyderi Friimanni Kristianin puolesta hallitsi; ja vaikka Ruotsin
päämies tapettiin viimmenimitetyltä kaksitappelossa, niin taisi linna
kuitenki hetimiten tulla otetuksi.

Seuraavana vuotena 1522 kävi Tammikuussa Kristianilta kaikille


linnanhaltioille Suomessa käsky, jossa heitä haastetaan tappamahan
ne kiini saadut ja linnoissa säilytetyt Herrat Gustavin puolluksesta.
Sentähden antoi Volffi ottaa hengen kaikilta Turun linnassa löytyviltä
Suomen Herroilta, joiden seassa oli Tönnes Erikssoni Totti ja
Lakmanni Pohjais-Suomessa Henrikki Steenssoni. Samanlainen
surma olisi myös tullut Erikki Flemingille, mutta hän oli ajoissa
saanut tiedon Kuninkaan käskystä ja mietti keinoja, mitenkä pelastaa
itsensä ja muitaki maanmiehistänsä. Hän tekeysi siis Kristianin
paraaksi ystäväksi, jonka kautta sai Volffin hyväsuosion itseensä,
hän tarjousi karkaamaan piirittäjöitten päälle, johonka vaaralliseksi
katsottuun yritykseen linnassa olevat Ruotsalaiset sotamiehet piti
pantaman, sillä heidän kuolemasta ei paljon huolittu. Tämä lauma
piti lisättämän Danskalaisilla, jotka pitäisivät Ruotsalaiset kurissa.
Fleminki sai salaa sanan Ruotsin päämiehelle aikomisistansa, ja kun
hän oli käynyt ulos linnasta, niin rupesivat karkaajat ja
päällenkarattavat yhessä tappamaan niitä muassa olevia
Danskalaisia, ja Fleminki miehinensä oli vapautettu. — Turun linnaa
piiritettiin aina keväimeen asti, jolloin Severini Norbyy tuli sen avuksi.
Niilo Arvidssoni ja Ruotsalaiset, joilla oli kovin vähä voimia
vastukseksi, täytyivät nyt vetäytä pois Turusta. Heidän lähtiissä
kirposi tapaturmaisesti tuli yhteen ruutitynnyriin, ja siitä syttyi tulipalo
kaupunkiin, joka palaissansa Danskan sotaväeltä ryöstettiin.
Ruotsalaiset pakenivat maan sisälöille Hämeeseen, jonnekka
Danskalainen ei heitä ajanut perästä. Pispa Arvidi Kurkki, joll'ei enää
ollut Kuusiston linnassa turvapaikkaa, pakeni Danskalaisten edellä
Raumaan, sieltä meritse Ulvilaan, sieltä Nääräpäähän, ja sieltä aikoi
tulla Ruotsiin, mutta hukkui merihädäässä monen vapasukuisen
miehen kanssa Suomesta, jotka olivat perehinensä hänen seurassa
olleet. Sinne meni Suomen 23:mas ja viimmeinen paavinuskoinen
pispa. Hämeesehen paenneista miehistä, joilla ei enää ollut toivoa
saada maata puollustetuksi, jakaupi sotalauma: Erikki Fleminki
menee isoimman joukon kanssa ja yhdistäypi Gustavi Vaasen
laumoihin; Niilo Grabbe jääpi Suomeen, varustaa itsellensä pienen
laivaston, hätyyttää sillä Danskalaisia, missä vaan heitä tapaa
pienemmissä joukoissa, ilmautuu välistä Raaseporissa, Porvossa
elikkä Kokemäessä (Kuusistossa?), pakenee hädän tultua Vironki
puolelle, ja tekee sillä keinon paljon pahaa Kristianin väelle. —
Danskalaiset hävittävät rantamaita Suomessa; Kuusiston linna
otetaan heiltä sisälle; Norbyy purjehtii sinne tänne Ruotsin ja
Suomen välillä, auttain ahdistettuja linnoja rualla ja väellä. Niinpä
käski hän Thuomas Volffinki Suomesta ottaa ruokatarpeita, minkä
voisi saada, ja viedä niitä Tukhulmiin. Volffi lähtiki suurella
laivajoukolla anottua apua viemään. Mutta Gustavi Vaase oli
Lybekkiläisten avulla saanut sotalaivoja, jotka piilivät Ruotsin
luotojen välillä ja nyt tulivat ottivat koko Volffin laivaston
sisuksinensa, ynnä Volffin itsensä vankiksi, ja sitte hirtettiin hän
tammeen, ansaituksi kostoksi monista hirmutöistänsä.

Gustavi Vaasella kävivät toimet hyvästi Ruotsissa: yksi linna toisen


perästä otettiin häneltä, yksi etu seurasi toistansa. Tukhulmi oli vielä
Danskalaisilla. Sitä piiritettiin monelta haaralta, ja Norbyyn apuanto
estettiin. Kristianilla ja hänen puoltajilla ei näytä olleen ollenkaan
tointa ja tolkkua muuhun kun hirmutöihin ja ilkeyksiin. Se vaikutti,
että Danskanki Raati ja Herrat jo rupesivat häntä pelkäämään ja
vihaamaan. He antoivat kruunun Fredrikki 1:mäiselle, joka teki liiton
Hansalaisten kanssa. Kristiani ei uskaltanut vastustaa, kokosi
tavaroita, minkä sai, ja purjehti v. 1523 Huhtikuussa muutamilla
laivoilla pois Danmarkista, heittäin ijäksi päiväksi kruununsa. Sittä eli
hän kruunuheittona, pidettiin lopulla 27 vuotta vankina ja kuoliki siinä
tilassa. Tässä oli hänen oman mielettömyytensä kosto! Mutta
Fredrikki otti Danskan kruunun ja tahtoi hänki Kalmari-yhdistyksen
ehdoilla saada Ruotsi allensa, josta hän kirjoitti Ruotsiin. Vaan sieltä
vastasi Raati: että he olivat valinneet Gustavi 1:sen Erikssonin
Ruotsin Kuninkaaksi. Se oli tapahtunut Strengnääsin
Riikinkokouksessa, 7:tenä päivänä Kesäkuuta. Niin päätyi Kalmari-
yhdistys, jonka onnettomuus oli kestänyt 126 vuotta. Samassa
kuussa antausi Tukhulmiki Gustaville, ja pian oli koko Ruotsi hänen
hallussa ja vapaana.

Kun Kuningas Gustavi 1:nen oli saanut Ruotsin perkatuksi


Danskalaisista, niin tuli Suomen vuoro. Elokuussa v. 1523 lähetti hän
sinne vahvan sotalauman Ruotsalaisia, Saksalaisia ja Suomalaisia,
Amiraalin Iivari Flemingin myötä, jonka piti veljensä Erikki Flemingin
kanssa ajaa Danskalaiset matkoinsa. Armeia nousi maalle Kuusiston
linnan tykönä ja otti sen toissa päivänä välirynnäköllä. Sitte meni se
Turkuun, jonka linna 12:ta päivän perästä saatiin otetuksi. Alussa
kävi Danskan sotajoukko Ruotsalaisia vastaan, mutta vetäysi pian
Hämeenlinnan kautta Viipuriin, kun oli saanut tarkempia tietoja
vihollistensa voimasta. Ruotsalaiset jakausivat nyt pienempiin
joukkoihin, jotka vähitellen ottivat Hämeen, Raaseporin, Savon ja
Viipurin linnat Danskalaisilta; jälkimmäinen otettiin Niilo Grabbelta.
Ennen Joulua oli koko Suomi tempastu vihollisten kourista. Kun ei
ollut Danmarkista apua odotettavana, niin menetti Danskan puollus
rohkeutensa, ja eivät he tahtoneet eivätkä voineet pitemmältä
vastustella. Näin tuli Suomi vapaaksi Danskalaisista.

2. Suomen sisämäisistä asioista Paavinuskon aikana.

Kukin aika on, omituisen luontonsa ja laatunsa puolesta, muista


eroitettu: niin myös Paavinuskon aika. Tässä tahdomma nyt sovitella
muutamia ennen mainimatta jääneitä eli jo mainittujaki asianhaaroja
yhteen; sillä täydellisempätä osotusta tämän monesta syystä kyllä
merkillisen ajan elämään emme voi antaa.

Ensisti tahdomma Kirkollisuuden puolta katsella. Siellä kohtaa


meitä heti Paavikunnan rakennus. Roomin seurakunnalla, joka
Apostolein aikana perustettiin, oli, niinkuin muillaki, pispansa. Kun
muutamain vuosisatain perästä Kristinusko oli pilaumassa, ja sen
opettajat maallista kunniata ja rikkautta rupesivat halailemaan, niin
syntyi Roomin valtakaupungin pispain päässä se ajatus, että he
muka olisivat Apostoli Pietarin jälkeenseuraajat virassa, joille taivaan
avaimet olisivat jätetyt. Sentähden rupesivat he muitten Kristikunnan
Pispain sivulla edellisyyttä tahtomaan. Heitä kutsuttiin paapoiksi,
josta sanasta Paavi muukaloimalla on tullut. Tämä tuuma onnistikin.
Roomissa kasvoivat Paavit aina enemmin kunniassa ja voimassa;
mutta siinä samassa kasvoi heidän maallinenki, Kristillisyydestä
erkaneva ja maallisia tarkoittava, mielikin. Sillä keinoin oli Paavi pian
saanut koko Kristikunnan allensa, paitsi Greekan kirkkoa, joka
hänestä erkani eikä tahtonut häntä totella.

Kun Kristinuskoa ruvettiin Suomeen levittämähän, oli Paavein


valta jo täydessä voimassaan, ja he hallitsivat ikääskun mahtavat
Kirkkoherrat, joitten pitäjän alle puoli Euroopata kuului ja maksoi
heille tihuntia. Heillä oli Roomissa Konsistoriumi, jonka jäseniä
kutsuttiin Kardinaaleiksi, ja niiten piti olla Paavein neuvonantajina ja
auttajina Kristikuntaa hallitessa. Myös piti heidän valita Paaveja, kun
entinen oli kuollut. Tämän Roomin kirkkovallan alle kuuluivat ensistä
Pääpispat (Arkhipispat), jotka tavallisesti vihkivät allensa kuuluvia
Pispoja ja pitivät jotaki komentoa heidän yli. Valittu, vaan vielä
vihkimätöin, pispa sai nimen Elektus (Valipispa). Mutta Pääpispainki
yli oli välistä asetettu Priimas eli Priimaspispa. Suomi, niinkuin
Ruotsikin, kuului Lundin Priimaspispan ja Upsalan Pääpispan alle.
Samatekkun Paavilla oli myös pispoilla Konsistoriuminsa eli
Tuomiokapituli, joka heitä valitsi ja auttoi hiippakuntaa hallitessa.
Tuomiokapitulin jäseniä löytyi Suomessa lopulla 12, joista
Tuomioprovasti (Archipraepositus), Arkhidiakonus ja Dekaanus olivat
muita etevämmät, ja niitä muita kutsuttiin alhaisemmiksi
Tuomioherroiksi (Kaniikeiksi). Tuomiokapitulilla oli alussa
tuomitsemista useimmissa rikosseikoissa, ja myöhemminki oli sillä
monessa asiassa ratkasemisen oikeus, vaikka Lakmanneja ja muita
Tuomareita jo löytyi meidän maassa. Papit olivat alhaisempia
hengellisiä ja toimittivat jumalanpalvelua seurakunnissa maalla ja
kaupungeissa. Papeilla oli välistä vierellä Kappalainen (Capellanus),
eli edestänsä virkaa toimittava Sialainen (Vicarius). Muita papillisia
virkoja olivat Diakonein ja Khuoripappein (Chorales) virat. Ilman sitä
löytyi alhaisempia, lukkarintapaisia kirkonvirkoja monesta lajista. Kun
Paavi tahtoi saada jotakin toimitetuksi kaukana Roomista olevissa
maissa, niin kirjoitti hän siitä Bullia pispoille eli muille; vaan kun asia
vaati, niin lähetti hän Legaateja edestänsä seikan selvittämään. —
Paitsi näitä maallisia pappeja löytyi myös muita, jotka suuremman
pyhyyden perään pyörivät ja elivät yhteydessä Luostareissa
(Kluostareissa). Niitä laitoksia löytyi erityisiä miehille ja naisille, eli
munkki- ja nunnaluostareita. Päällysmies kutsuttiin Apotiksi
(naisluostareissa Apetissaksi), ja sitä lähin virka oli Priorin
(Priorinnan eli Naispriorin), muista alhaisemmista mainimatta.
Tämmöisiä luostereita oli erilajista, joilla oli itsekkullaki omituiset
asetuksensa, tarkoittavat puhdasta, kaikesta irstaisuudesta ja
ylöllisyydestä vapaata, jumalisuuden harjoituksille vihittyä, elämätä.
Suomessa löytyi luostareita kolmesta munkkiseurasta eli ordenista,
nimittäin: kaksi Dominikaniluostaria, joista yksi oli Turussa ja toinen
Viipurissa: kolme Franciskani- luostaria, joista yksi oli Viipurissa,
toinen Raumassa, ja kolmas oli Köökarin luostari Ahvenanmaalla:
yksi Brigittiniluostari Naantalissa, jossa oli munkkeja ja nunnia
yhessä ja joka oli Vadstenan luostarista Ruotsissa saanut alkunsa.
(Kahden ensiksi nimitetyn munkkiseuran perustajat olivat Dominikus,
Hispaniasta, ja Franciskus, Italiasta. Kumpiki seura sai
vahvistuksensa Paavilta v. 1215 ja levisi heti sen perästä
pohjaiseenki. Brigittinein perustaja oli se mainio unien näkijä Pyhä
Brigitta Ruotsista, joka kuoli v. 1373.) Kun Kristinuskoa ensin ruvettin
Suomessa saarnaamaan, niin tarvittiin arvattavasti pappeja, jotka
maan omalla kielellä voisivat pakanoita opettaa ja saada heitä
erhetyksistänsä luopumaan. Mutta semmoisia saatettiin ainoastaan
sillä tavalla saada, että kääntyneitä pakanoita papeiksi opetettiin.
Sentähden onki arveltu jo aikuisin koululaitoksen löytyneen
pispanistuimen tekönä, jossa papiksi aivotut miehet saivat vähän
opetuksensa. Pispanistuimen muutettua Turkuun pitkitti tämä koulu,
Turun kathedralikoulun nimellä, oloansa. Sillä oli Tuomio-kapitulin
jäseniä opettajina, ja se sai vanhaan aikaan niin suuren arvon, että
Ruotsistaki tuli nuoria miehiä siinä oppimaan. Paitsi tätä löytyi
jokaisessa luostarissa koululaitos, joista Rauman koulu (Collegium
Raumense) oli varsin mainio Paavinajan loppupuolella. Näissä
kouluissa tehtiin erinomattain papinalkuja virkaansa mahdollisiksi.
Mutta jos joku tahtoi saada täydellisemmän ja laveamman opin, niin
täytyi hänen ulkomaisissa opistoissa, niminomaisesti Pariisin ja sittä
Praagin ynnä Leiptsigin Korkiopistoissa, keksiä tietoja, niinkuin
monesta pispasta olemme jo nähneet. Alhaisempain pappein ei
näytä tarvinneen maatansa ulempana käydä oppia hakemassa.
Oppineilta Suomessa kokoonpannuista kirjoista ei löydy paljo
mainittavata, paitsi että eräs Johannes Budde eli Rääki, joka
Paavinajan loppupuolella asui välistä Vadstenan, välistä Naantalin
luostarissa, on kirjoittanut usiampia kirjoja jumalisesta sisälläpidosta.
Rahvasta ei opetettu lukemaan, vaan ainoastaan muutamia
rukouksia ulkoa taitamaan.

Sitä myöten kun Kristillisyys levesi maassa ja asukkaita lisäysi,


rakettiin myös Kirkkoja. Nousion ja Räntämäen kirkot taisivat olla
kaikkian ensimmäiset; Hämeessä taisi Hattulan kirkko, Karjalassa
Viipurin ja Savilahden eli Mikkelin, Pohjanmaalla Mustasaaren,
Pietarsaaren, Salon ja Kemin kirkot olla ensimmäiset. Seurakuntia
jaettiin sittä aikaa myöten pienemmiksi, ja jokainen sai tiettävästi
pappinsa, joka kirkonmenoja toimitteli, kasti ja jakoi Sakramentit.
Ulkonainen koreus oli kirkoissa tarkoitettu, varsinki Tuomiokirkossa,
jossa Alttareita oli kyllin rakettu Pyhäin kunniaksi ja muistoksi.
Kirkonmenoista oli Messu etevin temppu: vähemmässä arvossa
pidettin Sakramentit, joita oli silloin seitsemän, ja Saarna, joka
useimmiten, niinkuin muukin jumalanpalvelu, tapahtui latinaksi, ilman
että kuunteliat mitään siitä ymmärtivät. Messuamalla toivottiin saada
sielut Kiirastulen (eli Perkantotulen) piinasta pelastetuksi, ja
semmoisia messuja eneni lopulla niin, että papit saivat melkeen
päivät päästänsä kirkossa veisata ja loilotella. Kaikki jumalisuus oli
täytetty ulkonaisten menoin harjoituksella; Raamattu oli papeillenki
tuntematoin kirja; ja jos joku vähän vapaammasti uskalsi ajatella, eli
käytti itseänsä jotenki Kirkon asetuksia ja tapoja vastoin, niin joutui
hän Pannaan s.o. suljettiin Kirkon yhteydestä. Siihen siaan olemme
nähneet, kuinka Aneita, eli syntianteen vakuutuskirjoja, jaettiin niille,
jotka Kirkkoa rikastuttivat. Pyhiä miehiä pidettin aivan
epäjumalisessa kunniassa, ja heille pidettiin omituisia juhlapäiviä,
jonka kautta tiettävästi joutopäivät enenivät ja työpäivät vähenivät.
Näitten Pyhäin lukuun kuului e. m. Suomen ensimmäinen pispa
Pyhä Henrikki: ja pispa Hemminkikin tehtiin v. 1514 Pyhäksi, vaan se
tapahtui kovin myöhä, ett'ei hänellä ollut siitä pitkällistä kunniata.
Tämmöisten Pyhäin sanottin tehneen paljo Ihmettöitä kuolemansaki
jälkeen; ja toivottiin heidän ei ainoastan esirukouksillansa taivaassa,
vaan myöskin liikanaisten hyväin töittensä lahjoittamisella, voivan
hankkia anteeksi saamisen syntisille ihmisille, vaikka on kylläkin
epäiltävä asia, jos moni näistä Pyhistä itsekkään oli taivaassa saanut
siaa.

Nyt ovat Kansakuntaisuuden asiat silmäiltävät. Niinkuin Paavi


hengellisillä siteillä hallitsi Kristikuntaa ja oli pispain päänä, niin piti
myös Roomin eli Saksan Keisarin olla Kuningasten ja Ruhtinaien
yhteisenä päänä: edellisellä piti hengellinen valtikka, jälkimäiselle
miekka siinä Kristikunnan yhteisessä valtakunnasa oleman.
Tämmöisen näemmä kaiketi tarkoituksen olleen yhteisen Historian
keskiajalla, vaikk'ei se koskaan saanut varsin aikaan; sillä ensistä
nousi pian yhtäläisiä riitoja Paavein ja Keisarein välillä, ja toiseksi
eivät Kuninkaat ja muut Ruhtinaatkaan usein paljo Keisaria totelleet.
Erinomattain olivat pohjaiset riikit omin päinsä. Ainaki olemme siv. 99
nähneet esimerkin senlaisesta Saksan Keisarin luullusta
ylinäisyydestä Suomenki perukan yli. Ruotsin Kuninkaat elikkä,
oikeimmin sanottu, Kuninkailta läänityksillä lahjoitetut ylimykset,
pitivät siis maallisen hallituksen Suomessa Paavinuskon ajalla. Mutta
ei alussa vielä niin. Suomi oli Paavein ja Turun pispain toimella, eli
ainaki Kristinuskon levittämisen tarkoituksessa, tullut valloitetuksi; ja
sentähden saivatki pispat ensiaikoina pian yksinään hallita ja vallita
isänmaassamme, niinkuin myös käyttää kaikki tulot omaksi ja Kirkon
hyväksi. Vasta Beero I:mäinen antoi osan maarahoista Kuninkaalle,
ja noin 1284 tuli vasta Birgeri Jaarlin poika Bengtti, Herttuan
korkonimellä, Suomen ensimmäiseksi maalliseksi haltiaksi. Siitä
lähin löytyi aina mahtavia Herroja, jotka Kuninkaalta olivat saaneet,
joko Suomen kokonaan eli osia siitä maasta, lahjaksi allensa. Näihin
ovat myös Linnanhaltiat luettavat, joilla oli jokuntapainen komento
linnan alle kuuluvan maan yli, ja joitten nimet ovat osiksi meihin asti
säilyneet tiedossa. Vasta Pähkinäsaaren rauhan perästä tavataan (v.
1324) ensimmäinen Lakmanni maassamme. Sen perästä jaettiin
Suomi v. 1435 kahteen Lakikuntaan, ja silloin asetettiin myös
Maanoikeus (katso siv. 90), mutta tämä oikeus herkesi heti
asettajansa kuoltua. Muuten tavataan Suomessa tällä ajalla
Kihlakunnan Tuomareita, Fouteja j.n.e. Talonpoikaisista valittiin
silloinki ymmärtäviä miehiä Lautamiehiksi, jotka Tuomarin kanssa
istuivat oikeutta. Lykätyt asiat menivät kihlakunnan oikeudesta
Lakmanniin, sieltä Tutkintakeräjihin (ruots. Räffteting), joita Kuningas
itse eli jonku siaisensa kautta piti kerran vuodessa. Muuten oli lupa
heti edestuoda asiansa korkeammanki tuomio-istuimen eteen, ilman
sen käyttämättä alemmassa oikeuspaikassa. Kuningas piti myös
erinomaisissa tapahuksissa jonkutapaista kihlakunnan oikeutta, jota
kutsuttin Oikasukeräjiksi (ruots. Rättareting).

Näin olivat Ruotsalaiset tuoneet oman maansa asetukset


Suomeen. Se oli myös määräämättömästi hyvä asia, ett'eivät he,
niinkuin Virolaisten kanssa tehtiin, laskeneet Suomen rahvasta
orjuuteen, vaan antoivat sen omituista maata viljellä ja omaisuutta
itsellensä hankkia. Ennen isännättömille erämaille raketuista taloista
tuli Veromaita, vaan kun kruunu oli sittemmin laskenut allensa kaikki
erämaat, niin tulivat siellä raivatut tilukset Kruununmaiksi. Paitsi näitä
löytyi Kuninkaankartanoita, (Kuninkaan ja hänen miesten ravinta- ja
asuntapaikat,) Maallisia Vapaamaita, Hengellisiä Vapaamaita,
(Kirkon alle kuuluvat talot,) y.m., jotka eivät varsinaisesti veroa
maksaneet. Isoin vero oli maksettava papistolle. Tämä oli Tihunti eli
Kymmenekset, maksettu ensistä metsän eläinten nahkoissa,
myöhemmin jyvissäki, mutta Ruotsalaisilta uutisasukkailta
lehmänannilla nk. voilla, juustolla ja muulla senlaisella. Edellisessä
tapauksessa sanottiin makson tapahtuneen Karjalan ja jälkimäisessä
Helsingin lakia myöten. Verot olivat alussa sangen pienet, vaan niitä
lisättiin ajan kuluissa. Viimmen ruvettiin niitä rahassaki kantamaan,
kun se oli kauppiasten kautta tullut maassa tavalliseksi, ehkä oli
alussa lupa kahdeksan talonpojan arvion jälkeen antaa rahan siasta
kalujaki. Muutoin oli työnteko linnoissa ja kuninkaankartanoissa
sangen painavainen velvollisuus talonpojalle.

Mitä Kauppaan Paavinuskon ajalla tulee, niin olemme jo ennen


(siv. 62 seur.) puhuneet siitä, kun Hansalaiset kävivät Novgorodin
kanssa. Mutta Karjalaiset ja Ruotsalainen vartoväki Viipurissa
taisivat välistä ryöstämisillänsä sitä kauppaa estää, koska mainittu
seura pyysi ja saiki ensistä v. 1295 Kuningas Birgeriltä, sittä muillaki
ajoilla ja muiltaki Ruhtinailta, suojakirjoja kaupankäyntiinsä
Nevajoella. Siellä ja muillakin paikoilla vaihtoivat he Suomalaisten
kaluja itsellensä. Muuten asettausi heitä, kaupan vuoksi, maassaki
asumaan, jonka tähden, koska he usein taisivat olla kotosin
Saksasta Saksanmaalla, kauppamiehiä vieläki paikoin kutsutaan
Saksoiksi ja Saksalaisia tavallisesti Saksalaisiksi. Kaupungit ja
linnat, joissa heillä taisi olla varsinaiset kauppapoikkansa, olivat
Suomessa syntyneet seuraavassa järjestyksessä: Turku,
Hämeenlinna, Viipuri, Ulvilan eli Porin kaupunki, Raasepori ja
Korsholma, Porvo, Rauma, Naantali, Savonlinna, paitsi Käkisalmea,
Landskruunaa ja Pähkinälinnaa, joitten alustat Pähkinäsaaren
rauhan perästä kuuluivat Venäjän alle. Näistä oli Turku mahtavin
kaupallansa ei ainoastaan Suomessa, mutta koko Ruotsin
vallakunnassaki oli se mahtavimpia: sitälähin oli Viipuri. Pienempäin
kaupunkein täytyi viedä kalunsa Tukhulmiin, mikä ei paikalla tullut
Hansalaisten asiamiehiltä ostetuksi. Pohjanmaalla oli lohen ja
silahkan pyynti hyvin tuottavainen keino, ja jokein suilla kokousi
siellä vuosittain kalan ostajia Tukhulmista ynnä muistaki Ruotsin ja
Suomen kaupungeista, ja varsinki Torniossa tavattiin Juhannuksen
aikana ulkomaalaisiaki, niinkuin Venäläisiä ja Norjalaisia, käymässä.
Emme tiedä minkä osan Pirkkalaiset ottivat tässä kaupassa, vaan on
ainaki syy arvella sen ei olleen aivan vähäisen. (Oikeemmasti
kutsuttaisiin nämät kentiesi suomeksiki Birkaarleiksi, joka sana
merkitsee porimiestä eli linnamiestä, sillä Pirkkalan pitäjäs taisi
saada heistä nimensä, eikä toisappäin; sekä muutenki erotteeksi
mainitun pitäjän asukkaista.) Vuonna 1328 eräältä Kuninkaan
mieheltä kirjoitetusta kirjasta nähdään, että mainitun
kauppiaisseuran miehiä oli silloin jo tullut Norlanniinki asumaan.
Samassa kirjoituksessa seisoo myös kielto, "ett'ei kenenkään pitänyt
estää Lappalaisia metsänkäynnissänsä, ei Pirkkalaistenkaan, jotka
tulevat niitten Lappalaisten asuntapaikoille, viipyvät heidän luona,
elikkä palaavat heidän tyköä tavaroinensa." Muuten näyttävät
Pirkkalaiset tällä ajalla käyneen aina Satakunnassa ja Turussa asti
kauppimassa ja keinottelemassa.

Tapain perustehena on kullakin ajalla Uskon eli jumalisuuden


hyvempi eli huonompi tila. Kristillisyys oli tällä Paavinuskon ajalla
menettänyt kaiken koko ihmistä parantavan luonteensa ja muuttunut
ulkonaiseksi harjoitukseksi, jonka sivulla ihmisen sydän sai olla
alallaan luonnollisessa pahuudessansa, joka usein ulkonaisilla töillä
vielä tuli peitetyksi ja kaunistelluksi; — ja niin olivat tavatki sitä
myöten. Ehkä tiettävästi joukossa aina löytyi parempiaki, (niinkuin
e.m. voisi arvella monesta oman hyötynsä ja henkensäki vaaralla
Kristinuskoa levittävästä miehestä valloittamisen ajalla,) on kuitenki
tämän ajan muoto siltä kohdalta sangan kamala tarkemmin
katsovalle. Papit olivat tavallisesti, joko ulkokullatuita pyhiä, jotka
hyvillä töillänsä ja pyhyytensä harjoituksilla tahtoivat taivasta
itsellensä kiskoa, elikkä rypivät he ulkonaisestikki suurissa
synneissä. Heille oli e. m. tullut Paavilta kielto, ett'eivät saisi naida;
mutta sen siaan tavataan heillä jalkanvaimoja, joitten kanssa
synnyttivät lapsia. Samate oli juopumus ei harvassa löyttävä vika.
Maalliset Herrat rasittivat talonpoikia väkikestingeillä ja muutenki,
käyttivät väärin oikeutta, ottivat lahjoja ja elivät hekin usein pahasti ja
törkiästi. Kun maakunnan päämiehet ja opettajat olivat senlaisia, niin
mahtoi tila olla ei aivan kaunis rahvahassakaan, ehk'ei liene samaan
määrään ollut; sillä raaka kansa tulee usein luontonsa vereksiltä
voimilta pelastetuksi elämän irstaisuuteen aivan syvältä
tahraumasta. Eteläis-Suomessa taisi Paavinusko syvemmältä
juurtua rahvaaseen ja ajaa ulos pakanalliset tavat ja muistot, (jonka
tähden Hämäläisten vanhimmat Runot ovatki siksehen unhotuksiin
kadonneet); vaan selvän pakanallisuuden siaan tuli epäuskollinen
pakanallisuus Kristinuskon nimellä ja muodolla. Maamme
pohjaisemmilla paikoilla näyttää pakanallisuus vielä olleen joksiki
voimissaan ja kukistamatoinna, jos kohtaki lie rahvas ylipäätä siellä
myös ollut kastettu. Sen todistavat siltä ajalta peräiset ja meihen asti
säilyneet Karjalaiset Runot, joissa Kiessus, Neitsyt Maaria, Santti
Pietari j.n.e. tavataan yhdessä arvossa Ukon, Väinämöisen,
Ilmarisen, ynnä muitten jumalain ja sankarein rinnalla. Vanha
pakanaisusko lisättiin Raamatussa tavattavilla persoonain nimillä,
joitten toimituksihin sommiteltiin entisten jumalain työt, kaikki sekasin
ja kamoittavassa hämmennyksessä. Niin on e.m. Vapahtajakin sillä
keinoin saatut omanlaatuisen elämäkertansa, joka on, osiksi
präntätyistä osiksi pränttäämättömistä, Runoista nähtävä. — Lopuksi
tahdomma vielä mainita Veljeyksistä (ruotsiksi: Brödraskap, Gilden),
joita laitettiin jonkun Pyhän eli pyhityksen muistoksi. Niihin yhdistyi
mies- kun vaimoväkeäki, omituisten asetusten alla jumalisuuden
harjoituksia ja rakkauden töitä täyttämään, niinkuin myös määrätyillä
ajoilla kestinkiä ja kemua pitämään. Semmoisia tietään kaksi
löytyneen Suomessa, nimittäin Pyhän Annan ja Kolmen Kuninkaan
Veljeykset (Fraternitates S:tæ Annæ & Trium Regum), jotka pispa
Maunus Tavastin aikana saivat alkunsa, paitsi mitä meikäläisillä
saattoi olla Ruotsin kanssa yhteyttä senlaisissa laitoksissa.
IV.

Kolmas Aikakausi.

Suomi Ruotsin vallan alla evangeliumisen uskon aikana.

Tähänasti on kirjoitettu Suomen olosta Pakanallisuuden ja


Paavinuskon aikana: edellisemmästä ajasta sangen lyhyesti,
jälkimäisestä vähäistä pitemmältä, ehkä siitäki vaillinaisesti.
Pakanallisuudessa tavataan esivanhempamme upotetut ja vaipuneet
Luonnon typeryyteen, jonka moninaiset voimat heiltä tehdään
jumalallisiksi Haltioiksi, ja kuvaillen laulavatki he yhteyttänsä sen
jumaloitetun Luonnon kanssa: Paavinuskon kautta tulee Kristillisyys
ulkonaisesti heidän sekaan, alkaa päältäpäin särkeä heidän
luonnollista eloa ja oloa — sillä ei opetus käynyt varsinaisesta
luonnon muutoksesta, vaan oli päältäpäin pakoitettu ja
sisäänkuritettu heihin — ja siitä tulee omankaltainen ulkoa kullattu
sivistys, joka kyllä saa kansan luonnollisesta tilastansa siirretyksi,
vaan ei voi sitä parantaa. Parannuksen siaan turmeltuvat tavat vielä
enemmin: se luonnollinen kauneus, kun on kukkaisella tavattava ja
on pakanallisuudelle antanut sen, vanhimmista Runoistansa meitä
vastaan vieläki huohtavan, yksikertaisen ihanuutensa, katoaa

You might also like