The organisation was perfect, and all talks that I attended were very well prepared. There were lots of tracks in parallel - so, I might have missed some interesting ones. Here are the ones I attended:
- API Management for Serverless and Multi-Cloud by Prithpal Bhogill and Kelsey Hightower. It started with a short introduction into Apigee, an API management platform that provides versioning, authorization, service discovery, metrics, tracing etc. and that is extensible for different backends. The following demos were shown:
1. How to easily deploy and run your Go server using GCP-native tools: Go code -> Dockerfile -> Cloud Build -> Cloud Run & Apigee (incl. authentication & tracing).
2. Apigee: A mashup of containers run by Cloud Run and Cloud Functions incl. response mixin.
3. Apigee: The above mashup plus a function running on AWS Lambda showing how to start going multi-cloud and the easy composition of building blocks running in multiple environments. - Kubernetes and VS Code: Zero to Deployed by David Gageot. A short demo of Cloud Code for VS Code.
- Google Cloud Platform from 1 to 100 Million Users by Harry Lin and Helen Lo. This talk presented a journey of how to improve the availability and scalability of a classical 3-tier web application (frontend, backend, database): GCE instance groups, load balancer, Cloud SQL (incl. read replicas & failover), Memorystore for caching, global load balancer to go multi-region, Cloud DNS, Cloud CDN, Spanner to enable data changes across multiple regions.
- Securing Serverless by Breaking In by Hayley Denbraver. Key takeaways for me:
1. Check your dependencies and the dependencies of your dependencies.
2. Fewer functions mean smaller attack surface. - Fast and Lean Data Science With TPUs by Martin Görner and Nik Spirin. The motivation for this talk was visual object recognition with RetinaNet using Focal Loss. Beside an introduction into the TPU architecture (vector processing unit & matrix multiplication unit) and its efficient data types, a model was trained live on ML Engine during the talk and the TPU usage in Keras was shown.
- Build Mobile Apps with Flutter and Google Maps by Brett Morgan and Matthew Sullivan. During this talk an app locating ice cream stores in San Francisco was developed. It used Firestore and Google Maps with Flutter in less than 250 lines of code and showed some available packages and the development support (e.g. IDE plugins, hot reload, package manager).
- Super-Charge Your GKE Developer Workflow in Visual Studio Code and IntelliJ by Etan Shaul and Ian Talarico. Some live coding using an example bookshelf application and Cloud Code incl. deployment to GKE, remote debugging, the Jib maven plugin and the cluster explorer.
- Montage Maker: Building Scaling Serverless Apps by Brent Shaffer. Some lessons learnt when developing a serverless video split and compose application: the maximum runtime of a Cloud Function is nine minutes, there's a maximum of 1000 function invocations per second and a maximum of 1000 outstanding events within Cloud Pub/Sub, the maximum memory used by a Cloud Function is 2 GB etc.
- Traffic Director and Envoy-Based L7 ILB for Production-Grade Service Mesh and Istio by Mike Columbus and Prajakta Joshi. Introduction into Traffic Director, a GCP-managed control plane offering global load balancing, autoscaling, traffic control incl. policies etc. for Istio, especially the Envoy proxy. It's still beta, and things like mTLS and improved observability are to come. A failover for an application running on two GKE clusters in different regions was demoed.
- Data Warehousing With BigQuery: Best Practices by Ryan McDowell and Alban Perillat-Merceroz. Lots of best practices concerning BigQuery:
- Compressed Avro is the fastest data format for data ingestion (followed by uncompressed Avro, Parquet/ORC, CSV, JSON, compressed CSV, compressed JSON).
- Prefer ELT over ETL; load data into raw and staging tables before propagating into reporting tables; use the Dataflow templates provided by Google.
- In schema design denormalization can speed up queries, e.g. for tightly coupled or immutable relationships.
- Use partitioning to cut down costs on reading data.
- Cluster frequently accessed fields either by natural partitioning or by a fake date column.
- Prefer hashing for deterministic surrogate keys derived from business key.
- Use slot reservations to prioritize workloads and monitor these slots.
- Segment users by roles and isolate their workloads by hierarchical reservations. - Istio in Production: Day 2 Traffic Routing by Megan O'Keefe. After a short introduction into Istio and its components (Envoy, Pilot, Mixer, Citadel etc.), she demoed a bunch of features in a live session: traffic splitting, content-based routing, circuit breaking, fault injection/chaos testing, istio-ingressgateway, how to secure egress traffic etc.
- Scalable and Manageable: A Deep-Dive Into GKE Networking Best Practices by Bowei Du and Mahesh Narayanan. A nice rundown about using VPC-native GKE clusters, the use of private clusters with master-authorized networks for best security, container-native load balancing to avoid request imbalance and for best performance, a detailed overview of the Pod lifecycle (liveness, readiness, healthcheck), the importance of signal handling within the application and "terminationGracePeriodSeconds", failure handling ("PodAntiAffinity") etc.
- Running Jenkins CI/CD with GKE by Jeff Fry. A short intro and on-screen demo of the Jenkins K8s plugin.
- Debugging Istio: How to Fix a Broken Service Mesh by Megan O'Keefe and Sandeep Parikh. This session was awesome! It was a hands-on demo session on how to debug traffic routing, missing metrics and problems with mTLS. Nice tool used during the session: Stern.
- Canary Deployments With Istio and Kubernetes Using Spinnaker by Nora Lutz and Andrew Phillips. A nice overview of how to do canary deployments using Istio's "DestinationRule" and "VirtualService" and how Spinnaker adds visibility for these types of deployments by leveraging Kayenta.
- How Retailers Prepare for Black Friday on Google Cloud Platform by Kiran Davuluri, Andre Fatala and Jimit Ladha. Some stories about how retailers use capacity planning and change freezes to stabilize the peak season.
- Performance Tuning Go Applications on GCP by Valentin Deleplace. This talk covered the following topics:
- Use sync.WaitGroup to synchronize on asynchronously started Go routines.
- Run benchmarks: go test -bench=.
- Generate and view a trace: go test -bench=. -trace a.out && go tool trace a.out
- Generate and view a CPU profile: go test -bench=. -cpuprofile a.prof && go tool pprof -http=:6060 a.prof
- Use the Linux perf tool.
- Detect data access races: go test -race
- Run the escape analysis (stack allocation -> heap allocation): go build -gcflags=-m
