Atamel.Dev

Codelab - Gemini for Developers

atamel@gmail.com (Mete Atamel) — Fri, 13 Feb 2026 00:00:00 +0000

Gemini for Developers

The Gemini ecosystem has evolved into a comprehensive suite of models, tools, and APIs. Whether you are “vibe-coding” a web app or deploying enterprise-grade agents, navigating the options can be overwhelming.

I am happy to announce a new Gemini for Developers codelab. This codelab is designed to teach you everything you need to know about the Gemini ecosystem, from the different model flavors to tools powered by Gemini to integration using the Google Gen AI SDK and the new Interactions API.

Gemini Interactions API - One interface for models and agents

atamel@gmail.com (Mete Atamel) — Tue, 03 Feb 2026 00:00:00 +0000

Interactions API overview

GenAI is rapidly moving from simple “prompt-and-response” patterns to complex, agentic workflows. To support this shift, Google recently introduced the Interactions API, a new unified foundation designed specifically for building with both models and agents.

In this post, I’ll introduce the core concepts of the Interactions API and walk through some of the samples available in my genai-samples repository.

What is the Interactions API?

Traditionally, developers had to use the Gemini API to talk to the models and another framework like Agent Development Kit (ADK) to create and manage agents. Currently in beta, the Interactions API simplifies this by providing a single interface for:

Introducing Google Cloud VertexAI Extensions for .NET

atamel@gmail.com (Mete Atamel) — Fri, 30 Jan 2026 00:00:00 +0000

Hero image

In October 2024, Microsoft announced the Microsoft.Extensions.AI.Abstractions and Microsoft.Extensions.AI libraries for .NET. These libraries provide the .NET ecosystem with essential abstractions for integrating AI services into .NET applications from various providers such as Open AI, Azure, Google.

Today, we’re happy to announce the Google.Cloud.VertexAI.Extensions library. This is the Vertex AI implementation of Microsoft.Extensions.AI. It enables .NET developers to integrate Google Gemini models on Vertex AI via the Microsoft.Extensions.AI abstractions.

Parallel agents in Antigravity

atamel@gmail.com (Mete Atamel) — Mon, 19 Jan 2026 00:00:00 +0000

Hero image

Google Antigravity transforms your regular IDE into an agentic development platform. In my previous blog posts, I showed some of the unique features of Antigravity compared to a regular IDE. In today’s blog post, I’ll talk about what makes Antigravity truly unique: Its ability to spin up and manage multiple agents.

Antigravity modes

Antigravity has two modes: Editor and Agent Manager.

Editor is your familiar IDE with an agent on the side to help you with tasks. You can read more about it in my previous blog post Google Antigravity Editor - Tips & Tricks and learn how to provide feedback to the agent in Provide Feedback to Google Antigravity and how to customize it in Customize Google Antigravity with rules and workflows.

Provide Feedback to Google Antigravity

atamel@gmail.com (Mete Atamel) — Wed, 10 Dec 2025 00:00:00 +0000

Google Antigravity Provide Feedback

At the heart of Google Antigravity is its ability to effortlessly gather your feedback at every stage of the experience. In this blog post, I will show you all the different ways you can provide feedback to Antigravity.

As the agent works on a task, it creates different artifacts along the way:

An implementation plan and a task list (before coding)
Code diffs (as it generates code)
A walkthrough to verify the results (after coding)

These artifacts are a way for Antigravity to communicate its plans and progress. More importantly, they’re also a way for you to provide feedback to the agent in Google docs style comments. This is very useful to effectively steer the agent in the direction you want.

Google Antigravity Editor - Tips & Tricks

atamel@gmail.com (Mete Atamel) — Mon, 01 Dec 2025 00:00:00 +0000

Google Antigravity Tips and Tricks

Google Antigravity is an agentic development platform where you have your familiar code editor along with a powerful agent on the side. In today’s post, I want to show you some tips and tricks for the code editor.

Setup and Extensions

In a typical setup, you’d have the editor, the terminal, and the agent visible:

Antigravity IDE

Customize Google Antigravity with rules and workflows

atamel@gmail.com (Mete Atamel) — Tue, 25 Nov 2025 00:00:00 +0000

Google Antigravity

Google Antigravity was announced last week as the next generation agentic IDE. I’m very impressed with it so far. It already helped me to upgrade my blog to the latest Hugo (that I’ve been putting off for a long time). It even recognized that some of the shortcodes (eg. Twitter) from the old version changed in the new version and automatically updated my blog posts with the new version of the shortcodes. Nice!

RAG just got much easier with File Search Tool in Gemini API

atamel@gmail.com (Mete Atamel) — Thu, 13 Nov 2025 00:00:00 +0000

File Search Tool

The Gemini team at Google recently announced the File Search Tool, a fully managed RAG system built directly into the Gemini API as a simple, integrated, and scalable way to ground Gemini. I gave it a try and I’m impressed how easy it is to use to ground Gemini with your own data.

In this blog post, I’ll introduce the File Search Tool and show you a concrete example.

Quick Guide to ADK Callbacks

atamel@gmail.com (Mete Atamel) — Mon, 03 Nov 2025 00:00:00 +0000

I’ve been exploring the Agent Developer Kit (ADK) and its powerful callbacks feature. In this blog post, I want to outline what callbacks are and provide a sample agent with all the callbacks implemented for a quick reference and testing.

At its core, an agent framework like ADK gives you a sequence of steps:

receive input → invoke model → invoke tools → return output

In real-world systems, we often need to hook into these steps for logging, guarding, caching, altering prompts or results, or dynamically changing behaviour based on session state. That’s exactly where callbacks come in. Think of callbacks as “checkpoints” in the agent’s lifecycle. The ADK framework automatically calls your functions at these key stages, giving you a chance to intervene.

Vibe coding an AI Trivia Quest app with Google AI Studio

atamel@gmail.com (Mete Atamel) — Mon, 27 Oct 2025 00:00:00 +0000

A few days ago, I saw Logan Kilpatrick’s Tweet about the new AI-first vibe coding experience in AI Studio:

Introducing the new AI first vibe coding experience in @GoogleAIStudio! Built to take you from prompt to production with Gemini, and optimized for AI app creation. Start building AI apps for free : )

More updates and features to come! pic.twitter.com/HpI7Dsl8Bj
— Logan Kilpatrick (@OfficialLoganK) October 21, 2025

Last time I tried AI Studio for vibe coding, it was mostly a single-page web application with all the code in a single file (which wasn’t ideal).

Introducing Google Gen AI .NET SDK

atamel@gmail.com (Mete Atamel) — Thu, 23 Oct 2025 00:00:00 +0000

Introducing Google Gen AI .NET SDK

Last year, we announced the Google Gen AI SDK as the new unified library for Gemini on Google AI (via the Gemini Developer API) and Vertex AI (via the Vertex AI API). At the time, it was only a Python SDK. Since then, the team has been busy adding support for Go, Node.js, and Java but my favorite language, C#, was missing until now.

Search Flights with Gemini Computer Use model

atamel@gmail.com (Mete Atamel) — Mon, 20 Oct 2025 00:00:00 +0000

Earlier this month, the Gemini 2.5 Computer Use model was announced. This model is specialized in interacting with graphical user interfaces (UI). This is useful in scenarios where a structured API does not exist for the model to interact with (via function calling). Instead, you can use the Computer Use model to directly interact with user interfaces such as filling and submitting forms.

It’s important to note that the model does not interact with the UI directly. As input, the model receives the user request, a screenshot of the environment, and a history of recent actions. As output, it generates a function call representing a UI action such as clicking or typing (see the full list of supported UI actions). It’s the client-side code’s responsibility to execute the received action and the process continues in a loop:

Secure your LLM apps with Google Cloud Model Armor

atamel@gmail.com (Mete Atamel) — Mon, 11 Aug 2025 00:00:00 +0000

Model armor

It’s crucial to secure inputs and outputs to and from your Large Language Model (LLM). Failure to do so can result in prompt injections, jailbreaking, sensitive information exposure, and more (as detailed in OWASP Top 10 for Large Language Model Applications).

I previously talked about LLM Guard and Vertex AI and showed how to use LLM Guard to secure LLMs. Google Cloud has its own service to secure LLMs: Model Armor. In this post, we’ll explore Model Armor and see how it can help to safeguard your LLM applications.

Gen AI Evaluation Service - Multimodal Metrics

atamel@gmail.com (Mete Atamel) — Tue, 05 Aug 2025 00:00:00 +0000

Multimodal metrics

This is the sixth and final post in my Vertex AI Gen AI Evaluation Service blog post series. In the previous posts, we covered computation-based, model-based, tool-use, and agent metrics. These metrics measure different aspects of an LLM response in different ways but one thing they all had in common: they are all for text-based outputs.

LLMs nowadays also produce multimodal (images, videos) outputs. How do you evaluate multimodal outputs? That’s the topic of this blog post.

Gen AI Evaluation Service - Agent Metrics

atamel@gmail.com (Mete Atamel) — Fri, 01 Aug 2025 00:00:00 +0000

Agent metrics

In my previous Gen AI Evaluation Service - Tool-Use Metrics post, we talked about LLMs calling external tools and how you can use tool-use metrics to evaluate how good those tool calls are. In today’s fifth post of my Vertex AI Gen AI Evaluation Service blog post series, we will talk about a related topic: agents and agent metrics.

What are agents?

There are many definitions of agents but an agent is essentially a piece of software that acts autonomously to achieve specific goals. They use LLMs to perform tasks, utilize external tools, coordinate with other agents, and ultimately produce a response to the user.

Gen AI Evaluation Service - Tool-Use Metrics

atamel@gmail.com (Mete Atamel) — Mon, 28 Jul 2025 00:00:00 +0000

Tool-use metrics

I’m continuing my Vertex AI Gen AI Evaluation Service blog post series. In today’s fourth post of the series, I will talk about tool-use metrics.

What is tool use?

Tool use, also known as function calling, provides the LLM with definitions of external tools (for example, a get_current_weather function). When processing a prompt, the model determines if a tool is needed and, if so, outputs structured data specifying the tool to call and its parameters (for example, get_current_weather(location='London')).

Gen AI Evaluation Service - Model-Based Metrics

atamel@gmail.com (Mete Atamel) — Tue, 08 Jul 2025 00:00:00 +0000

Model-based metrics

In the Gen AI Evaluation Service - An Overview post, I introduced Vertex AI’s Gen AI evaluation service and talked about the various classes of metrics it supports. In the Gen AI Evaluation Service - Computation-Based Metrics post, we delved into computation-based metrics, what they provide, and discussed their limitations. In today’s third post of the series, we’ll dive into model-based metrics.

The idea of model-based metrics is to use a judge model to evaluate the output of a candidate model. Using an LLM as a judge allows more flexible and rich evaluations that the computational/statistical metrics fail to do.

Gen AI Evaluation Service - Computation-Based Metrics

atamel@gmail.com (Mete Atamel) — Wed, 02 Jul 2025 00:00:00 +0000

In my Gen AI Evaluation Service - An Overview post, I introduced Vertex AI’s Gen AI evaluation service and talked about the various classes of metrics it supports. In today’s post, I want to dive into computation-based metrics, what they provide, and discuss their limitations.

Computation-based metrics are metrics that can be calculated using a mathematical formula. They’re deterministic – the same input produces the same score, unlike model-based metrics where you might get slightly different scores for the same input.

Gen AI Evaluation Service - An Overview

atamel@gmail.com (Mete Atamel) — Mon, 30 Jun 2025 00:00:00 +0000

Generating content with Large Language Models (LLMs) is easy. Determining whether the generated content is good is hard. That’s why evaluating LLM outputs with metrics is crucial. Previously, I talked about DeepEval and Promptfoo as some of the tools you can use for LLM evaluation. I also talked about RAG triad metrics specifically for Retrieval Augmented Generation (RAG) evaluation for LLMs.

In the next few posts, I want to talk about a Google Cloud specific evaluation service: the Gen AI evaluation service in Vertex AI. The Gen AI evaluation service in Vertex AI lets you evaluate any generative model or application against a set of criteria or your own custom criteria.

Evaluating RAG pipelines with the RAG triad

atamel@gmail.com (Mete Atamel) — Wed, 14 May 2025 00:00:00 +0000

Retrieval-Augmented Generation (RAG) emerged as a dominant framework for feeding Large Language Models (LLMs) the context beyond the scope of their training data and enabling LLMs to respond with more grounded answers and fewer hallucinations based on that context.

However, designing an effective RAG pipeline can be challenging. You need to answer questions such as:

How should you parse and chunk text documents for vector embedding? What chunk size and overlay size should you use?
What vector embedding model should you use?
What retrieval method should I use to fetch the relevant context? How many documents should you retrieve by default? Does the retriever 1.actually manage to retrieve the applicable documents?
Does the generator actually generate content that is in line with the retrieved context? What parameters (model, prompt template, temperature) work better?

The only way to objectively answer these questions is to measure how well the RAG pipeline works, but what exactly do you measure, and how do you measure it? This is the topic I’ll cover here.

DeepEval adds native support for Gemini as an LLM Judge

atamel@gmail.com (Mete Atamel) — Tue, 29 Apr 2025 00:00:00 +0000

DeepEval and Gemini

In my previous post on DeepEval and Vertex AI, I introduced DeepEval, an open-source evaluation framework for LLMs. I also demonstrated how to use Gemini (on Vertex AI) as an LLM Judge in DeepEval, replacing the default OpenAI judge to evaluate outputs from other LLMs. At that time, the Gemini integration with DeepEval wasn’t ideal and I had to implement my own integration.

Thanks to the excellent work by Roy Arsan in PR #1493, DeepEval now includes native Gemini integration. Since it’s built on the new unified Google GenAI SDK, DeepEval supports Gemini models running both on Vertex AI and Google AI. Nice!

Much simplified function calling in Gemini 2.X models

atamel@gmail.com (Mete Atamel) — Tue, 08 Apr 2025 00:00:00 +0000

Last year, in my Deep dive into function calling in Gemini post, I talked about how to do function calling in Gemini. More specifically, I showed how to call two functions (location_to_lat_long and lat_long_to_weather) to get the weather information for a location from Gemini. It wasn’t difficult but it involved a lot of steps for 2 simple function calls.

I’m pleased to see that the latest Gemini 2.X models and the unified Google Gen AI SDK (that I talked about in my Gemini on Vertex AI and Google AI now unified with the new Google Gen AI SDK) made function calling much simpler.

RAG with a PDF using LlamaIndex and SimpleVectorStore on Vertex AI

atamel@gmail.com (Mete Atamel) — Mon, 24 Mar 2025 00:00:00 +0000

LlamaIndex and Vertex AI

Previously, I showed how to do RAG with a PDF using LangChain and Annoy Vector Store and RAG with a PDF using LangChain and Firestore Vector Store. Both used a PDF as the RAG backend and used LangChain as the LLM framework to orchestrate RAG ingestion and retrieval.

LlamaIndex is another popular LLM framework. I wondered how to set up the same PDF based RAG pipeline with LlamaIndex and Vertex AI but I didn’t find a good sample. I put together a sample and in this short post, I show how to set up the same PDF based RAG pipeline with LlamaIndex.

Ensuring AI Code Quality with SonarQube + Gemini Code Assist

atamel@gmail.com (Mete Atamel) — Tue, 04 Mar 2025 00:00:00 +0000

In my previous Code Quality in the Age of AI-Assisted Development blog post, I talked about how generative AI is changing the way we code and its potential impact on code quality. I recommended using static code analysis tools to monitor AI-generated code, ensuring its security and quality.

In this blog post, I will explore one such static code analysis tool, SonarQube, and see how it improves the quality of AI-generated code.

Code Quality in the Age of AI-Assisted Development

atamel@gmail.com (Mete Atamel) — Tue, 28 Jan 2025 00:00:00 +0000

As developers transition from manual coding to AI-assisted coding, an increasing share of code is now being generated by AI. This shift has significantly boosted productivity and efficiency, but it raises an important question: how does AI-assisted development impact code quality? How can we ensure that AI-generated code maintains high quality, adheres to good style, and follows best practices? This question has been on my mind recently, and it is the topic of this blog post.

Improve the RAG pipeline with RAG triad metrics

atamel@gmail.com (Mete Atamel) — Tue, 21 Jan 2025 00:00:00 +0000

In my previous RAG Evaluation - A Step-by-Step Guide with DeepEval post, I showed how to evaluate a RAG pipeline with the RAG triad metrics using DeepEval and Vertex AI. As a recap, these were the results:

RAG triad with DeepEval

Answer relevancy and faithfulness metrics had perfect 1.0 scores whereas contextual relevancy was low at 0.29 because we retrieved a lot of irrelevant context:

The score is 0.29 because while the context mentions relevant information such as "The Cymbal Starlight 2024 has a cargo
capacity of 13.5 cubic feet", much of the retrieved context is irrelevant. For example, several statements discuss
towing capacity like "Your Cymbal Starlight 2024 is not equipped to tow a trailer", or describe how to access/load cargo
like "To access the cargo area, open the trunk lid using the trunk release lever located in the driver's footwell"
instead of focusing on the requested cargo capacity.

Can we improve this? Let’s take a look.

RAG Evaluation - A Step-by-Step Guide with DeepEval

atamel@gmail.com (Mete Atamel) — Tue, 14 Jan 2025 00:00:00 +0000

In my previous Evaluating RAG pipelines post, I introduced two approaches to evaluating RAG pipelines. In this post, I will show you how to implement these two approaches in detail. The implementation will naturally depend on the framework you use. In my case, I’ll be using DeepEval, an open-source evaluation framework.

Approach 1: Evaluating Retrieval and Generator separately

As a recap, in this approach, you evaluate the retriever and generator of the RAG pipeline separately with their own separate metrics. This approach allows to pinpoint issues at the retriever and the generator level:

Evaluating RAG pipelines

atamel@gmail.com (Mete Atamel) — Thu, 09 Jan 2025 00:00:00 +0000

Retrieval-Augmented Generation (RAG) emerged as a dominant framework to feed LLMs the context beyond the scope of its training data and enable LLMs to respond with more grounded answers with less hallucinations based on that context.

However, designing an effective RAG pipeline can be challenging. You need to answer certain questions such as:

How should you parse and chunk text documents for embedding? What chunk and overlay size to use?
What embedding model is best for your use case?
What retrieval method works most effectively? How many documents should you retrieve by default? Does the retriever actually manage to retrieve the relevant documents?
Does the generator actually generate content in line with the relevant context? What parameters (e.g. model, prompt template, temperature) work better?

The only way to objectively answer these questions is to measure how well the RAG pipeline works but what exactly do you measure? This is the topic of this blog post.

Gemini on Vertex AI and Google AI now unified with the new Google Gen AI SDK

atamel@gmail.com (Mete Atamel) — Tue, 17 Dec 2024 00:00:00 +0000

If you’ve been working with Gemini, you’ve likely encountered the two separate client libraries for Gemini: the Gemini library for Google AI vs. Vertex AI in Google Cloud. Even though the two libraries are quite similar, there are slight differences that make the two libraries non-interchangeable.

I usually start my experiments in Google AI and when it is time to switch to Vertex AI on Google Cloud, I couldn’t simply copy and paste my code. I had to go through updating my Google AI libraries to Vertex AI libraries. It wasn’t difficult but it was quite annoying.

Control LLM output with LangChain's structured and Pydantic output parsers

atamel@gmail.com (Mete Atamel) — Mon, 09 Dec 2024 00:00:00 +0000

In my previous Control LLM output with response type and schema post, I talked about how you can define a JSON response schema and Vertex AI makes sure the output of the Large Language Model (LLM) conforms to that schema.

In this post, I show how you can implement a similar response schema using LangChain’s structured output parser with any model. You can further get the output parsed and populated into Python classes automatically with the Pydantic output parser. This helps you to really narrow down and structure LLM outputs.

Tracing with Langtrace and Gemini

atamel@gmail.com (Mete Atamel) — Wed, 27 Nov 2024 00:00:00 +0000

Large Language Models (LLMs) feel like a totally new technology with totally new problems. It’s true to some extent but at the same time, they also have the same old problems that we had to tackle in traditional technology.

For example, how do you figure out which LLM calls are taking too long or have failed? At the bare minimum, you need logging but ideally, you use a full observability platform like OpenTelemetry with logging, tracing, metrics and more. You need the good old software engineering practices, such as observability, applied to new technologies like LLMs.

Batch prediction in Gemini

atamel@gmail.com (Mete Atamel) — Mon, 18 Nov 2024 00:00:00 +0000

LLMs are great in generating content on demand but if left unchecked, you can be left with a large bill at the end of the day. In my Control LLM costs with context caching post, I talked about how to limit costs by using context caching. Batch generation is another technique you can use to save time at a discounted price.

What’s batch generation?

Batch generation in Gemini allows you to send multiple generative AI requests in batches rather than one by one and get responses asynchronously either in a Cloud Storage bucket or a BigQuery table. This not only simplifies processing of large datasets, but it also saves time and money, as batch requests are processed in paralllel and discounted 50% from standard requests.

LLM Guard and Vertex AI

atamel@gmail.com (Mete Atamel) — Mon, 11 Nov 2024 00:00:00 +0000

LLM Guard and Vertex AI

I’ve been focusing on evaluation frameworks lately because I believe that the hardest problem while using LLMs is to make sure they behave properly. Are you getting the right outputs grounded with your data? Are outputs free of harmful or PII data? When you make a change to your RAG pipeline or to your prompts, are outputs getting better or worse? How do you know? You don’t know unless you measure. What do you measure and how? These are the sort of questions you need to answer and that’s when evaluation frameworks come into the picture.

Promptfoo and Vertex AI

atamel@gmail.com (Mete Atamel) — Mon, 04 Nov 2024 00:00:00 +0000

Promptfoo and Vertex AI

In my previous DeepEval and Vertex AI blog post, I talked about how crucial it is to have an evaluation framework in place when working with Large Language Models (LLMs) and introduced DeepEval as one of such evaluation frameworks.

Recently, I came across another LLM evaluation and security framework called Promptfoo. In this post, I will introduce Promptfoo, show what it provides for evaluations and security testing, and how it can be used with Vertex AI.

Firestore for Image Embeddings

atamel@gmail.com (Mete Atamel) — Tue, 29 Oct 2024 00:00:00 +0000

Firestore and LangChain

In my previous Firestore for Text Embedding and Similarity Search post, I talked about how Firestore and LangChain can help you to store text embeddings and do similarity searches against them. With multimodal embedding models, you can generate embeddings not only for text but for images and video as well. In this post, I will show you how to store image embeddings in Firestore and later use them for similarity search.

Firestore for Text Embedding and Similarity Search

atamel@gmail.com (Mete Atamel) — Wed, 09 Oct 2024 00:00:00 +0000

Firestore and LangChain

In my previous Persisting LLM chat history to Firestore post, I showed how to persist chat messages in Firestore for more meaningful and context-aware conversations. Another common requirement in LLM applications is to ground responses in data for more relevant answers. For that, you need embeddings. In this post, I want to talk specifically about text embeddings and how Firestore and LangChain can help you to store text embeddings and do similarity searches against them.

Persisting LLM chat history to Firestore

atamel@gmail.com (Mete Atamel) — Tue, 01 Oct 2024 00:00:00 +0000

Firestore and LangChain

Firestore has long been my go-to NoSQL backend for my serverless apps. Recently, it’s becoming my go-to backend for my LLM powered apps too. In this series of posts, I want to show you how Firestore can help for your LLM apps.

In the first post of the series, I want to talk about LLM powered chat applications. I know, not all LLM apps have to be chat based apps but a lot of them are because LLMs are simply very good at chat based communication.

Semantic Kernel and Gemini

atamel@gmail.com (Mete Atamel) — Mon, 19 Aug 2024 00:00:00 +0000

Semantic Kernel and VertexAI

Introduction

When you’re building a Large Language Model (LLMs) application, you typically start with the SDK of the LLM you’re trying to talk to. However, at some point, it might make sense to start using a higher level framework. This is especially true if you rely on multiple LLMs from different vendors. Instead of learning and using SDKs from multiple vendors, you can learn a higher level framework and use that to orchestrate your calls to multiple LLMs. These frameworks also have useful abstractions beyond simple LLM calls that accelerate LLM application development.

DeepEval and Vertex AI

atamel@gmail.com (Mete Atamel) — Mon, 12 Aug 2024 00:00:00 +0000

DeepEval and VertexAI

Introduction

When you’re working with Large Language Models (LLMs), it’s crucial to have an evaluation framework in place. Only by constantly evaluating and testing your LLM outputs, you can tell if the changes you’re making to prompts or the output you’re getting back from the LLM are actually good.

In this blog post, we’ll look into one of those evaluation frameworks called DeepEval, an open-source evaluation framework for LLMs. It allows to “unit test” LLM outputs in a similar way to Pytest. We’ll also see how DeepEval can be configured to work with Vertex AI.

Deep dive into function calling in Gemini

atamel@gmail.com (Mete Atamel) — Tue, 06 Aug 2024 00:00:00 +0000

Introduction

In this blog post, we’ll deep dive into function calling in Gemini. More specifically, you’ll see how to handle multiple and parallel function call requests from generate_content and chat interfaces and take a look at the new auto function calling feature through a sample weather application.

What is function calling?

Function Calling is useful to augment LLMs with more up-to-date data via external API calls.

You can define custom functions and provide these to an LLM. While processing a prompt, the LLM can choose to delegate tasks to the functions that you identify. The model does not call the functions directly but rather makes function call requests with parameters to your application. In turn, your application code responds to function call requests by calling external APIs and providing the responses back to the model, allowing the LLM to complete its response to the prompt.

Control LLM costs with context caching

atamel@gmail.com (Mete Atamel) — Fri, 19 Jul 2024 00:00:00 +0000

Context caching

Introduction

Some large language models (LLMs), such as Gemini 1.5 Flash or Gemini 1.5 Pro, have a very large context window. This is very useful if you want to analyze a big chunk of data, such as a whole book or a long video. On the other hand, it can get quite expensive if you keep sending the same large data in your prompts. Context caching can help.

Control LLM output with response type and schema

atamel@gmail.com (Mete Atamel) — Mon, 15 Jul 2024 00:00:00 +0000

Introduction

Large language models (LLMs) are great at generating content but the output format you get back can be a hit or miss sometimes.

For example, you ask for a JSON output in certain format and you might get free-form text or a JSON wrapped in markdown string or a proper JSON but with some required fields missing. If your application requires a strict format, this can be a real problem.

RAG API powered by LlamaIndex on Vertex AI

atamel@gmail.com (Mete Atamel) — Mon, 08 Jul 2024 00:00:00 +0000

LlamaIndex and Vertex AI

Introduction

Recently, I talked about why grounding LLMs is important and how to ground LLMs with public data using Google Search (Vertex AI’s Grounding with Google Search: how to use it and why) and with private data using Vertex AI Search (Grounding LLMs with your own data using Vertex AI Search).

In today’s post, I want to talk about another more flexible and customizable way of grounding your LLMs with private data: the RAG API powered by LlamaIndex on Vertex AI.

Grounding LLMs with your own data using Vertex AI Search

atamel@gmail.com (Mete Atamel) — Mon, 01 Jul 2024 00:00:00 +0000

Introduction

In my previous Vertex AI’s Grounding with Google Search: how to use it and why post, I explained why you need grounding with large language models (LLMs) and how Vertex AI’s grounding with Google Search can help to ground LLMs with public up-to-date data.

That’s great but you sometimes need to ground LLMs with your own private data. How can you do that? There are many ways but Vertex AI Search is the easiest way and that’s what I want to talk about today with a simple use case.

Give your LLM a quick lie detector test

atamel@gmail.com (Mete Atamel) — Thu, 06 Jun 2024 00:00:00 +0000

Lie Detector LLM

Introduction

It’s no secret that LLMs sometimes lie and they do so in a very confident kind of way. This might be OK for some applications but it can be a real problem if your application requires high levels of accuracy.

I remember when the first LLMs emerged back in early 2023. I tried some of the early models and it felt like they were hallucinating half of the time. More recently, it started feeling like LLMs are getting better at giving more factual answers. But it’s just a feeling and you can’t base application decisions (or any decision?) on feelings, can you?

The Consistency vs. Novelty Dilemma

atamel@gmail.com (Mete Atamel) — Sun, 02 Jun 2024 00:00:00 +0000

Consistency vs. Novelty

It’s been a while since I wrote a non-work related topic. Last time, I wrote about the unique kindness I experienced in Japan (see The Butterfly effect of kindness). This time, I want to write about a dilemma that I’ve been thinking about for a while.

When I reflect on my life so far, whenever I had some progress (learning a new skill, making new lasting connections, changing to a new job, losing weight), it was always due to consistency in my life. I was not traveling, I was not thinking about where to go, what to do, where to eat, how to get from point A to point B. I was in my familiar environment with a consistent (and maybe boring) routine where the basics of my life were in place. As a result, I had time, got bored, and started exploring. This consistency fueled boredom allowed me to explore an aspect of life that I wasn’t happy about and I put the time and energy into improving it.

Vertex AI's Grounding with Google Search - how to use it and why

atamel@gmail.com (Mete Atamel) — Wed, 29 May 2024 00:00:00 +0000

Introduction

Once in a while, you come across a feature that is so easy to use and so useful that you don’t know how you lived without it before. For me, Vertex AI’s Grounding with Google Search is one of those features.

In this blog post, I explain why you need grounding with large language models (LLMs) and how Vertex AI’s Grounding with Google Search can help with minimal effort on your part.

AsyncAPI gets a new version 3.0 and new operations

atamel@gmail.com (Mete Atamel) — Mon, 13 May 2024 00:00:00 +0000

Almost one year ago, I talked about AsyncAPI 2.6 and how confusing its publish and subscribe operations can be in my Understanding AsyncAPI’s publish & subscribe semantics with an example post.

Since then, a new 3.0 version of AsyncAPI has been released with breaking changes and a totally new send and receive operations.

In this blog post, I want to revisit the example from last year and show how to rewrite it for AsyncAPI 3.0 with the new send and receive operations.

A tour of Gemini 1.5 Pro samples

atamel@gmail.com (Mete Atamel) — Tue, 07 May 2024 00:00:00 +0000

Introduction

Back in February, Google announced Gemini 1.5 Pro with its impressive 1 million token context window.

Gemini 1.5 Pro

Larger context size means that Gemini 1.5 Pro can process vast amounts of information in one go — 1 hour of video, 11 hours of audio, 30,000 lines of code or over 700,000 words and the good news is that there’s good language support.

In this blog post, I will point out some samples utilizing Gemini 1.5 Pro in Google Cloud’s Vertex AI in different use cases and languages (Python, Node.js, Java, C#, Go).

Making API calls exactly once when using Workflows

atamel@gmail.com (Mete Atamel) — Fri, 03 May 2024 00:00:00 +0000

One challenge with any distributed system, including Workflows, is ensuring that requests sent from one service to another are processed exactly once, when needed; for example, when placing a customer order in a shipping queue, withdrawing funds from a bank account, or processing a payment.

In this blog post, we’ll provide an example of a website invoking Workflows, and Workflows in turn invoking a Cloud Function. We’ll show how to make sure both Workflows and the Cloud Function logic only runs once. We’ll also talk about how to invoke Workflows exactly once when using HTTP callbacks, Pub/Sub messages, or Cloud Tasks.

C# and Vertex AI Gemini streaming API bug and workaround

atamel@gmail.com (Mete Atamel) — Wed, 01 May 2024 00:00:00 +0000

A user recently reported an intermittent error with C# and Gemini 1.5 model on Vertex AI’s streaming API. In this blog post, I want to outline what the error is, what causes it, and how to avoid it with the hopes of saving some frustration for someone out there.

Error

The user reported using Google.Cloud.AIPlatform.V1 library with version 2.27.0 to use Gemini 1.5 via Vertex AI’s streaming API and running into an intermittent System.IO.IOException.

A Tour of Gemini Code Assist - Slides and Demos

atamel@gmail.com (Mete Atamel) — Wed, 24 Apr 2024 00:00:00 +0000

This week, I’m speaking at 3 meetups on Gemini Code Assist. My talk has a little introduction to GenAI and Gemini, followed by a series of hands-on demos that showcase different features of Gemini Code Assist.

In the demos, I setup Gemini Code Assist in Cloud Code IDE plugin in Visual Studio Code. Then, I show how to design and create an application, explain, run, generate, test, transform code, and finish with understanding logs with the help of Gemini.

Vertex AI Gemini generateContent (non-streaming) API

atamel@gmail.com (Mete Atamel) — Mon, 26 Feb 2024 00:00:00 +0000

Introduction

In my recent blog post, I’ve been exploring Vertex AI’s Gemini REST API and mainly talked about the streamGenerateContent method which is a streaming API.

Recently, a new method appeared in Vertex AI docs: generateContent which is the non-streaming (unary) version of the API.

In this short blog post, I take a closer look at the new non-streaming generateContent API and explain why it makes sense to use as a simpler API when the latency is not super critical.

Orchestrate Vertex AI’s PaLM and Gemini APIs with Workflows

atamel@gmail.com (Mete Atamel) — Thu, 22 Feb 2024 00:00:00 +0000

Everyone is excited about generative AI (gen AI) nowadays and rightfully so. You might be generating text with PaLM 2 or Gemini Pro, generating images with ImageGen 2, translating code from language to another with Codey, or describing images and videos with Gemini Pro Vision.

No matter how you’re using gen AI, at the end of the day, you’re calling an endpoint either with an SDK or a library or via a REST API. Workflows, my go-to service to orchestrate and automate other services, is more relevant than ever when it comes to gen AI.

Using Vertex AI Gemini from GAPIC libraries (C#)

atamel@gmail.com (Mete Atamel) — Wed, 14 Feb 2024 00:00:00 +0000

Gemini

Introduction

In my previous Using Vertex AI Gemini REST API post, I showed how to use the Gemini REST API from languages without SDK support yet such as C# and Rust.

There’s actually another way to use Gemini from languages without SDK support: GAPIC libraries. In this post, I show you how to use Vertex AI Gemini from GAPIC libraries, using C# as an example.

What is GAPIC?

At this point, you might be wondering: What’s GAPIC? GAPIC stands for Google API CodeGen. In Google Cloud, all services have auto-generated libraries from Google’s service proto files. Since these libraries are auto-generated, they’re not the easiest and most intuitive way of calling a service. Because of that, some services also have hand-written SDKs/libraries on top of GAPIC libraries.

Using Vertex AI Gemini REST API (C# and Rust)

atamel@gmail.com (Mete Atamel) — Mon, 05 Feb 2024 00:00:00 +0000

Introduction

Back in December, Google announced Gemini, its most capable and general model so far available from Google AI Studio and Google Cloud Vertex AI.

Gemini

The Try the Vertex AI Gemini API documentation page shows instructions on how to use the Gemini API from Python, Node.js, Java, and Go.

alt_text

That’s great but what about other languages?

Even though there are no official SDKs/libraries for other languages yet, you can use the Gemini REST API to access the same functionality with a little bit more work on your part.

The butterfly effect of kindness

atamel@gmail.com (Mete Atamel) — Fri, 02 Feb 2024 00:00:00 +0000

Butteryfly effect of kindess

I’ve been using my blog for work-related topics since I can remember. I don’t know why but recently, I had an itch to write about non-work related topics for no particular reason. I’m not sure if anyone would care or find my non-tech writing useful but I’ll definitely find it useful for me as a mark of my consciousness at a given time, so here we go.

Test and change an existing web app with Duet AI

atamel@gmail.com (Mete Atamel) — Mon, 29 Jan 2024 00:00:00 +0000

Duet AI

In the Create and deploy a new web app to Cloud Run with Duet AI post, I created a simple web application and deployed to Cloud Run using Duet AI’s help. Duet AI has been great to get a new and simple app up and running. But does it help for existing apps? Let’s figure it out.

In this blog post, I take an existing web app, explore it, test it, add a unit test, add new functionality, and add more unit tests all with the help of Duet AI. Again, I captured some lessons learned along the way to get the most out of Duet AI.

Create and deploy a new web app to Cloud Run with Duet AI

atamel@gmail.com (Mete Atamel) — Tue, 23 Jan 2024 00:00:00 +0000

Duet AI

I’ve been playing with Duet AI, Google’s AI-powered collaborator, recently to see how useful it can be for my development workflow. I’m pleasantly surprised how helpful Duet AI can be when provided with specific questions with the right context.

In this blog post, I document my journey of creating and deploying a new web application to Cloud Run with Duet AI’s help. I also capture some lessons learned along the way to get the most out of Duet AI.

Announcing Workflows execution steps history

atamel@gmail.com (Mete Atamel) — Sat, 20 Jan 2024 00:00:00 +0000

As you orchestrate more services with Workflows, the workflow gets more complicated with more steps, jumps, iterations, parallel branches. When the workflow execution inevitably fails at some point, you need to debug and figure out which step failed and why. So far, you only had an execution summary with inputs/outputs and logs to rely on in your execution debugging. While this was good enough for basic workflows, it didn’t provide step level debugging information.

C# library and samples for GenAI in Vertex AI

atamel@gmail.com (Mete Atamel) — Mon, 11 Dec 2023 00:00:00 +0000

In my previous post, I talked about multi-language libraries and samples for GenAI. In this post, I want to zoom into some C# specific information for GenAI in Vertex AI.

C# GenAI samples for Vertex AI

If you want to skip this blog post and just jump into code, there’s a collection of C# GenAI samples for Vertex AI.

C# GenAI samples for Vertex AI

Deploy and manage Kubernetes applications with Workflows

atamel@gmail.com (Mete Atamel) — Fri, 01 Dec 2023 00:00:00 +0000

Workflows is a versatile service in orchestrating and automating a wide range of use cases: microservices, business processes, Data and ML pipelines, IT operations, and more. It can also be used to automate deployment of containerized applications on Kubernetes Engine (GKE) and this got even easier with the newly released (in preview) Kubernetes API Connector.

The new Kubernetes API connector enables access to GKE services from Workflows and this in turn enables Kubernetes based resource management or orchestration, scheduled Kubernetes jobs, and more.

Multi-language libraries and samples for GenAI in Vertex AI

atamel@gmail.com (Mete Atamel) — Tue, 28 Nov 2023 00:00:00 +0000

You might think that you need to know Python to be able to use GenAI with VertexAI. While Python is the dominant language in GenAI (and Vertex AI is no exception in that regard), you can actually use GenAI in Vertex AI from other languages such as Java, C#, Node.js, Go, and more.

Let’s take a look at the details.

Vertex AI SDK for Python

The official SDK for Vertex AI is Vertex AI SDK for Python and as expected, it’s in Python. You can initialize Vertex AI SDK with some parameters and utilize GenAI models with a few lines of code:

Introducing a new Eventarc destination - internal HTTP endpoint in a VPC network

atamel@gmail.com (Mete Atamel) — Mon, 13 Nov 2023 00:00:00 +0000

Introduction

Eventarc helps users build event-driven architectures without having to implement, customize, or maintain the underlying infrastructure.

Eventarc has added support (in public preview) for delivering events to internal HTTP endpoints in a Virtual Private Cloud (VPC) network. Customers, especially large enterprises, often run compute (typically GKE or GCE) on VPC-private IPs, often behind internal load balancers. This launch will enable these services to consume Eventarc events.

Internal HTTP endpoints can be an internal IP address or fully qualified DNS name (FQDN) for any HTTP endpoint in the VPC network. Examples of destinations that can be targeted via the internal HTTP endpoints include Compute Engine VMs with internal IPs, services fronted by an L7 Internal Load Balancer, Private Service Connect endpoints, Google Kubernetes Engine Ingress, Google Kubernetes Engine Services, Cloud Run behind an internal Application Load Balancer and any destinations registered with Cloud DNS via DNS record.

What languages are supported in WebAssembly outside the browser?

atamel@gmail.com (Mete Atamel) — Thu, 07 Sep 2023 00:00:00 +0000

What languages are supported in WebAssembly running outside the browser? This is a question I often hear people ask. It’s has a complicated answer because:

WebAssembly outside the browser needs WASI and not all languages have WASI support in their toolchain.
Even if WASI is supported well in a language, WASI has its own limitations that you need to take into account.

In short, you can’t take any code written in any language and expect to compile and run it as a Wasm+Wasi module right now. Documentation on what’s supported is patchy or misleading at times. Unfortunately, you often need to try things out before knowing what works and what doesn’t.

Adding HTTP around Wasm with Wagi

atamel@gmail.com (Mete Atamel) — Tue, 18 Jul 2023 00:00:00 +0000

In my previous posts, I talked about how you can run WebAssembly (Wasm) outside the browser with Wasi and run it in a Docker container with runwasi. The Wasi specification allows Wasm modules access to things like the filesystem and environment variables (and I showed how in this blog post) but networking and threading are not implemented yet. This is severely limiting if you want to run HTTP based microservices on Wasm for example.

Buffer workflow executions with a Cloud Tasks queue

atamel@gmail.com (Mete Atamel) — Wed, 12 Jul 2023 00:00:00 +0000

Introduction

In my previous post, I talked about how you can use a parent workflow to execute child workflows in parallel for faster overall processing time and easier detection of errors. Another useful pattern is to use a Cloud Tasks queue to create Workflows executions and that’s the topic of this post.

When your application experiences a sudden surge of traffic, it’s natural to want to handle the increased load by creating a high number of concurrent workflow executions. However, Google Cloud’s Workflows enforces quotas to prevent abuse and ensure fair resource allocation. These quotas limit the maximum number of concurrent workflow executions per region, per project, for example, Workflows currently enforces a maximum of 2000 concurrent executions by default. Once this limit is reached, any new executions beyond the quota will fail with an HTTP 429 error.

Workflows executing other parallel workflows: A practical guide

atamel@gmail.com (Mete Atamel) — Sat, 08 Jul 2023 00:00:00 +0000

Introduction

There are numerous scenarios where you might want to execute tasks in parallel. One common use case involves dividing data into batches, processing each batch in parallel, and combining the results in the end. This approach not only enhances the speed of the overall processing but it also allows for easier error detection in smaller tasks.

On the other hand, setting up parallel tasks, monitoring them, handling errors in each task, and combining the results in the end is not trivial. Thankfully, Google Cloud’s Workflows can help. In this post, we will explore how you can use a parent workflow to set up and execute parallel child workflows.

Generative AI Short Courses by DeepLearning.AI

atamel@gmail.com (Mete Atamel) — Tue, 04 Jul 2023 00:00:00 +0000

Introduction

In my previous couple posts (post1, post2), I shared my detailed notes on Generative AI Learning Path in Google Cloud’s Skills Boost. It’s a great collection of courses to get started in GenAI, especially on the theory underpinning GenAI.

Since then, I discovered another great resource to learn more about GenAI: Learn Generative AI Short Courses by DeepLearning.AI from Andrew Ng.

In this post, I summarize what each course teaches you to help you decide which course to take. I highly recommend taking all 4 courses. They’re full of useful information and short enough that even if you’re not fully interested in the topic, you can still get a good idea about it in a short amount of time.

Running Wasm in a container

atamel@gmail.com (Mete Atamel) — Thu, 29 Jun 2023 00:00:00 +0000

Docker recently announced experimental support for running Wasm modules (see Announcing Docker+Wasm Technical Preview 2). In this blog post, I explain what this means and how to run a Wasm module in Docker.

Why run Wasm in a container?

In my Exploring WebAssembly outside the browser post, I mentioned how Wasm is faster, smaller, more secure, and more portable than a container. You might be wondering: Why take something faster, smaller, more secure, and more portable and run it in a container?

Compile Rust & Go to a Wasm+Wasi module and run in a Wasm runtime

atamel@gmail.com (Mete Atamel) — Mon, 26 Jun 2023 00:00:00 +0000

In my Exploring WebAssembly outside the browser post, I talked about how WebAssembly System Interface (WASI) enables Wasm modules to run outside the browser and interact with the host in a limited set of use cases that Wasi supports (see Wasi proposals).

WASI

In this blog post, let’s look into details of how to compile code to a Wasm+Wasi module and then run it in a Wasm runtime. Notice that I use Wasm+Wasi module deliberately (instead of just Wasm) because some languages have Wasm support and can run perfectly fine in the browser but they have no or limited Wasi support to run outside the browser.

Exploring WebAssembly outside the browser

atamel@gmail.com (Mete Atamel) — Tue, 20 Jun 2023 00:00:00 +0000

WebAssembly Logo

Introduction

WebAssembly (Wasm) was initially designed as a binary instruction format for executing native code efficiently within web browsers. The original use cases are focused on augmenting Javascript in the browser to run native code in a fast, portable, and secure way for games, 3D graphics, etc.

However, its potential extends far beyond the browser. In this blog post, we’ll delve into the exciting realm of running Wasm outside the browser, exploring its advantages, and relevant specifications.

Generative AI Learning Path Notes – Part 2

atamel@gmail.com (Mete Atamel) — Thu, 15 Jun 2023 00:00:00 +0000

If you’re looking to upskill in Generative AI, there’s a Generative AI Learning Path in Google Cloud Skills Boost. It currently consists of 10 courses and provides a good foundation on the theory behind Generative AI.

As I went through these courses myself, I took notes, as I learn best when I write things down. In part 1 of the blog series, I shared my notes for courses 1 to 6. In this part 2 of the blog series, I continue sharing my notes for courses 7 to 10.

Generative AI Learning Path Notes – Part 1

atamel@gmail.com (Mete Atamel) — Tue, 06 Jun 2023 00:00:00 +0000

If you’re looking to upskill in Generative AI (GenAI), there’s a Generative AI Learning Path in Google Cloud Skills Boost. It currently consists of 10 courses and provides a good foundation on the theory behind Generative AI and what tools and services Google provides in GenAI. The best part is that it’s completely free!

GenAI Learning Path

As I went through these courses myself, I took notes, as I learn best when I write things down. In this part 1 of the blog series, I want to share my notes for courses 1 to 6, in case you want to quickly read summaries of these courses.

New Batch connector for Workflows

atamel@gmail.com (Mete Atamel) — Tue, 30 May 2023 00:00:00 +0000

Batch and Workflows

Workflows just released a new connector for Batch that greatly simplifies how to create and run Batch jobs from Workflows. Let’s take a look how you can use the new Batch connector of Workflows.

Recap: Batch and Workflows

Batch is a fully managed service to schedule, queue, and execute batch jobs on Google’s infrastructure. These batch jobs run on Compute Engine VM instances but they are managed by Batch service, so you don’t have to provision and manage VM instances yourself.

Google Cloud Pub/Sub + AsyncAPI

atamel@gmail.com (Mete Atamel) — Thu, 25 May 2023 00:00:00 +0000

Cloud Pub/Sub and AsyncAPI

I’ve been covering different aspects of AsyncAPI in my recent blog posts. In this final post of my AsyncAPI blog post series, I want to talk about how to document Google Cloud’s Pub/Sub using AsyncAPI.

AsyncAPI has pretty good support for Google Pub/Sub, thanks to contributions from Jeremy Whitlock, an engineer from Google, and the flexibility baked in AsyncAPI spec. Jeremy also has a nice blog post on this topic that you can read for more details.

CloudEvents + AsyncAPI

atamel@gmail.com (Mete Atamel) — Tue, 23 May 2023 00:00:00 +0000

CloudEvents and AsyncAPI

I’ve been recently talking about CloudEvents and AsyncAPI,two of my favorite open-source specifications for event-driven architectures. In this blog post, I want to talk about how you can use CloudEvents and AsyncAPI together. More specifically, I’ll show you how to document CloudEvents enabled services using AsyncAPI, thanks to the flexibility and openness of both projects.

Recap: CloudEvents and AsyncAPI

Let’s first do a quick recap CloudEvents and AsyncAPI.

Understanding AsyncAPI's publish & subscribe semantics with an example

atamel@gmail.com (Mete Atamel) — Thu, 18 May 2023 00:00:00 +0000

In AsyncAPI, a channel can have a publish and subscribe operation. This can be confusing, depending on which perspective you’re considering (server vs. user) and what you’re comparing against (eg. WebSocket).

In this blog post, I want to go through an example to show you how to construct your AsyncAPI file with the right publish and subscribe semantics. As a bonus, I also show you how to refactor your AsyncAPI files with common configuration.

AsyncAPI Tools

atamel@gmail.com (Mete Atamel) — Tue, 16 May 2023 00:00:00 +0000

In my previous post, I talked about basic of AsyncAPI. In this post, I want to get into more details on some tools around AsyncAPI.

More specially, we’ll install AsyncAPI CLI and Generator, generate a sample AsyncAPI definition, visualize it in AsyncAPI Studio, and generate code from it. You’ll see how useful AsyncAPI can be in documenting and maintaining your event-driven architectures.

Install AsyncAPI tools

First, let’s install some of the AsyncAPI tools.

AsyncAPI Basics

atamel@gmail.com (Mete Atamel) — Fri, 12 May 2023 00:00:00 +0000

AsyncAPI Logo

Recently, I’ve been looking into AsyncAPI, an open-source specification and tools to document and maintain event-driven architectures (EDAs).

In this blog post, I want summarize the basics of AsyncAPI and point to some useful links to learn more. In future blog posts, I’ll get into more details of AsyncAPI.

AsyncAPI: Why? What?

AsyncAPI is an open source initiative with the goal of making event-driven APIs as easy as REST APIs. Fundamentally, it is a specification to define asynchronous APIs, similar to what OpenAPI (aka Swagger) does for REST APIs.

Buffer HTTP requests with Cloud Tasks

atamel@gmail.com (Mete Atamel) — Thu, 04 May 2023 00:00:00 +0000

Cloud Tasks is a fully-managed service that manages the execution, dispatch, and asynchronous delivery of a large number of tasks to App Engine or any arbitrary HTTP endpoint. You can also use a Cloud Tasks queue to buffer requests between services for more robust intra-service communication.

Cloud Tasks introduces two new features, the new queue-level routing configuration and BufferTask API. Together, they enable creating HTTP tasks and adding to a queue without needing the tasks client library.

Workflows gets an updated JSON Schema

atamel@gmail.com (Mete Atamel) — Tue, 11 Apr 2023 00:00:00 +0000

If you use Workflows, you’ve been crafting your Workflows definitions in YAML (or JSON). You’re probably painfully aware of the limited support you get in your IDE with syntax validation or auto-completion with these YAML definitions. This was due to Workflow’s schema being out of date, as I covered in my previous post last year.

I’m happy to report that our team recently updated the Workflows schema with the latest syntax. With a new schema, you get a much improved syntax validation and auto-completion of Workflows definition files in your favorite IDE.

CloudEvents Basics

atamel@gmail.com (Mete Atamel) — Mon, 03 Apr 2023 00:00:00 +0000

I talked about CloudEvents in the context of event-driven architectures before. In this post, let’s explore CloudEvents in more depth.

CloudEvents: Why? What?

CloudEvents Logo

CloudEvents is a popular specification for describing event data in a common way with the goal of increasing interoperability between different event systems.

Google Cloud’s Eventarc, open-source Knative, Azure’s Event Grid, and many more projects rely on CloudEvent specification to define their event formats.

Extending Cloud Code with custom templates

atamel@gmail.com (Mete Atamel) — Sat, 18 Mar 2023 00:00:00 +0000

Cloud Code is a set of IDE plugins for popular IDEs that make it easier to create, deploy and integrate applications with Google Cloud. Cloud Code provides an excellent extension mechanism through custom templates. In this post, I show you how you can create and use your own custom templates to add some features beyond those supported natively in Cloud Code, such as .NET functions, event triggered functions and more.

How to use Google Cloud Serverless tech to iterate quickly in a startup environment

atamel@gmail.com (Mete Atamel) — Thu, 15 Dec 2022 00:00:00 +0000

In a startup, you need to get to the MVP fast, gather feedback from early adopters, and iterate in a quick cycle. Anything that takes time away from developing and iterating on features delays the launch and that’s a serious problem when time-to-market is crucial.

Google Cloud offers products that can help you to build and run your backend services on a fully managed serverless platform, saving time and freeing you from the burden of provisioning and managing infrastructure needed to run those services. Less time on infrastructure means more time implementing and iterating on your services. Additionally, most serverless products have a pay-as-you-go pricing model with little upfront cost at the beginning. Pricing increases in line with the scale of your services and your startup, so you only pay for what you need, when you need it

Introducing Cloud Functions support in Cloud Code

atamel@gmail.com (Mete Atamel) — Mon, 12 Dec 2022 00:00:00 +0000

Cloud Code now supports Cloud Functions

Cloud Code has been providing IDE support for the development cycle of Kubernetes and Cloud Run applications for a while now. I’m happy to report that the Dec 2022 version (1.21.0) of Cloud Code now supports Cloud Functions!

In this first release of Cloud Functions support, you can:

Use the Cloud Functions Explorer to view your project’s Cloud Functions properties and source code.
Download your Cloud Functions to edit your code locally, then configure your local workspace to deploy those changes directly from Cloud Code.
Invoke your HTTP-triggered functions from VS Code.
Use the Cloud Code Logs Viewer to view logs from your Cloud Functions.

Let’s take a closer look.

Workflows patterns and best practices - Part 3

atamel@gmail.com (Mete Atamel) — Mon, 05 Dec 2022 00:00:00 +0000

This is a three-part series of posts, in which we summarize Workflows and service orchestration patterns. In this third and final post, we talk about managing workflow life cycles and the benefits of using Firestore with Workflows.

If you’re not careful, the workflow definitions you create with YAML or JSON can get out of hand pretty quickly. While it is possible to use subworkflows to define snippets of a workflow that can be reused from multiple workflows, Workflows does not support importing these subworkflows. Thankfully, there are other tools, such as Terraform, that can help.

Workflows patterns and best practices - Part 2

atamel@gmail.com (Mete Atamel) — Mon, 28 Nov 2022 00:00:00 +0000

This is part 2 of a three-part series of posts, in which we summarize Workflows and service orchestration patterns. You can apply these patterns to better take advantage of Workflows and service orchestration on Google Cloud.

In the first post, we introduced some general tips and tricks, as well as patterns for event-driven orchestrations, parallel steps, and connectors. This second post covers more advanced patterns.

Let’s dive in!

Design for resiliency with retries and the saga pattern It’s easy to put together a workflow that chains a series of services, especially if you assume that those services will never fail. This is a common distributed systems fallacy, however, because of course a service will fail at some point. The workflow step calling that service will fail, and then the whole workflow will fail. This is not what you want to see in a resilient architecture. Thankfully, Workflows has building blocks to handle both transient and permanent service failures.

Workflows patterns and best practices - Part 1

atamel@gmail.com (Mete Atamel) — Tue, 22 Nov 2022 00:00:00 +0000

For the last couple of years, we’ve been using Workflows, Google Cloud’s service orchestrator, to bring order to our serverless microservices architectures. As we used and gained more experience with Workflows and service orchestration, we shared what he had learned in conference talks, blog posts, samples, and tutorials. Along the way, some common patterns and best practices emerged.

To help you take better advantage of Workflows and service orchestration on Google Cloud, we’ve summarized these proven patterns and best practices in a three-part series of blog posts.

.NET 7 on Cloud Run

atamel@gmail.com (Mete Atamel) — Fri, 11 Nov 2022 00:00:00 +0000

.NET 7 on Cloud Run

.NET 7 was released a few days ago with new features and performance improvements and it’s already supported on Cloud Run on Google Cloud!

In this short blog post, I show you how to deploy a .NET 7 web app to Cloud Run.

Create a .NET 7 web app

First, make sure you’re on .NET 7:

dotnet --version
7.0.100

Create a simple web app:

Executing commands (gcloud, kubectl) from Workflows

atamel@gmail.com (Mete Atamel) — Mon, 17 Oct 2022 00:00:00 +0000

In a previous post, I showed how to manage the lifecycle of a virtual machine using Workflows and the Compute Engine connector. This works well when there’s a connector for the resource you’re trying to manage. When there is no connector, you can try to use the API of the resource from Workflows, if there’s one. Alternatively, you can also use my favorite command line tool to manage the resource: gcloud. Or if you’re managing a Kubernetes cluster, maybe you want to call kubectl instead.

Workflows that pause and wait for human approvals from Google Sheets

atamel@gmail.com (Mete Atamel) — Mon, 10 Oct 2022 00:00:00 +0000

I’ve been writing a series of posts to showcase Google Workspace and Google Cloud Workflows integration.

In my first post, I showed an IT automation use case in which a Google Sheets spreadsheet triggers a workflow to create virtual machines in Google Cloud. In the second post, I showed how to feed a Google Sheets spreadsheet with data from BigQuery using a workflow.

In this third and final post of the series, I show how to design a workflow that pauses and waits for human approvals from Google Sheets.

.NET 6 on Cloud Functions (2nd gen)

atamel@gmail.com (Mete Atamel) — Mon, 03 Oct 2022 00:00:00 +0000

Back in August, we announced the 2nd generation of Cloud Functions with longer request processing times, larger instances, new event sources with Eventarc, and more.

A few weeks ago, .NET 6 support (public preview) was silently added to Cloud Functions.

Let’s see how to deploy some .NET 6 functions to Cloud Functions 2nd gen.

Functions Framework for .NET

Functions Framework for .NET is the easiest way to create .NET functions for consuming HTTP or CloudEvent requests.

Writing to Google Sheets from Workflows

atamel@gmail.com (Mete Atamel) — Mon, 26 Sep 2022 00:00:00 +0000

In my previous post, I showed how to trigger a workflow in Google Cloud from a Google Sheets spreadsheet using Apps Script. In this post, I show how to do the reverse: write to Google Sheets from a workflow in Google Cloud.

Use case

Imagine you have some dataset in BigQuery. Periodically, you want to query and extract a subset of the dataset and save it to a Google Sheets spreadsheet. You can implement such a process with Workflows quite easily.

Multi-environment service orchestrations

atamel@gmail.com (Mete Atamel) — Tue, 20 Sep 2022 00:00:00 +0000

In a previous post, I showed how to use a GitOps approach to manage the deployment lifecycle of a service orchestration. This approach makes it easy to deploy changes to a workflow in a staging environment, run tests against it, and gradually roll out these changes to the production environment.

While GitOps helps to manage the deployment lifecycle, it’s not enough. Sometimes, you need to make changes to the workflow before deploying to different environments. You need to design workflows with multiple environments in mind.

GitOps your service orchestrations

atamel@gmail.com (Mete Atamel) — Fri, 16 Sep 2022 00:00:00 +0000

GitOps takes DevOps best practices used for application development (such as version control and CI/CD) and applies them to infrastructure automation. In GitOps, the Git repository serves as the source of truth and the CD pipeline is responsible for building, testing, and deploying the application code and the underlying infrastructure.

Nowadays, an application is not just code running on infrastructure that you own and operate. It is usually a set of first-party and third-party microservices working together in an event-driven architecture or with a central service orchestrator such as Workflows.

Triggering Workflows from Google Sheets

atamel@gmail.com (Mete Atamel) — Fri, 09 Sep 2022 00:00:00 +0000

Is it possible to integrate Google Workspace tools such as Calendar, Sheets, and Forms with Workflows? For example, can you trigger a workflow from a Google Form or a Sheet? Turns out, this is not only possible but also easier than you might think. Let me show you how with a sample use case.

Use case

Imagine you are an administrator in charge of allocating virtual machines (VM) in your cloud infrastructure to users. You want to capture user requests with the specifications for the VMs, have an approval step for the request, and then create the VM with an automated process.

Route Datadog monitoring alerts to Google Cloud with Eventarc

atamel@gmail.com (Mete Atamel) — Wed, 24 Aug 2022 00:00:00 +0000

A few weeks ago, we announced third-party event sources for Eventarc, with the first cohort of third-party providers by our ecosystem partners. This blog post describes how to listen for events from one of those third-party providers, Datadog, and route them to a service in Google Cloud via Eventarc.

Datadog is a monitoring platform for cloud applications. It brings together end-to-end traces, metrics, and logs to make your applications and infrastructure observable. In Datadog, you can create monitors that track metrics, events, logs, integration availability, and network endpoints, and you can set alert thresholds on those monitors. Once these thresholds are reached, Datadog notifies your teams or services via email, Slack, and now a Google Cloud service via Eventarc.

Creating Workflows that pause and wait for events

atamel@gmail.com (Mete Atamel) — Fri, 05 Aug 2022 00:00:00 +0000

In Workflows, it’s easy to chain various services together into an automated workflow. For some use cases, you might need to pause workflow execution and wait for some input. This input could be a human approval or an external service calling back with data needed to complete the workflow.

With Workflows callbacks, a workflow can create an HTTP endpoint and pause execution until it receives an HTTP callback to that endpoint. This is very useful for creating human-in-the-middle type workflows. In a previous blog post, Guillaume Laforge showed how to build an automated translation workflow with human validation using callbacks.

Trip report - Eight in-person conferences in eight weeks

atamel@gmail.com (Mete Atamel) — Fri, 15 Jul 2022 00:00:00 +0000

Careful what you wish for

My last in-person conference before the pandemic was NDC London back in January 2020. I distinctly remember being quite tired at the beginning of 2020. For me, 2019 had been a long year with 50+ speaking engagements at a variety of conferences all around the world. I just wanted to take a short break in early 2020.

Little did I know that the short break would turn into a 2.5 year long break due to a global pandemic. I’m extremely grateful that I was able to continue working and speaking in many online conferences during the pandemic. However, as the pandemic dragged on, my enthusiasm for online events diminished. I sorely missed connecting with other speakers, meeting attendees, and exploring the city I was speaking in.

Taking screenshots of web pages with Cloud Run jobs, Workflows, and Eventarc

atamel@gmail.com (Mete Atamel) — Thu, 16 Jun 2022 00:00:00 +0000

At Google Cloud I/O, we announced the public preview of Cloud Run jobs. Unlike Cloud Run services that run continuously to respond to web requests or events, Cloud Run jobs run code that performs some work and quits when the work is done. Cloud Run jobs are a good fit for administrative tasks such as database migration, scheduled work like nightly reports, or doing batch data transformation.

In this post, I show you a fully serverless, event-driven application to take screenshots of web pages, powered by Cloud Run jobs, Workflows, and Eventarc.

Worklows state management with Firestore

atamel@gmail.com (Mete Atamel) — Fri, 08 Apr 2022 00:00:00 +0000

Workflows Firestore

In Workflows, sometimes, you need to store some state, a key/value pair, in a step in one execution and later read that state in another step in another execution. There’s no intrinsic key/value store in Workflows. However, you can use Firestore as a key/value store and that’s what I want to show you here.

If you want to skip to see some samples, check out workflow.yaml.

Introducing Eventarc triggers for Workflows

atamel@gmail.com (Mete Atamel) — Fri, 01 Apr 2022 00:00:00 +0000

We’re happy to announce that you can now create Eventarc triggers to directly target Workflows destinations. Available as a preview feature, it simplifies event-driven orchestrations by enabling you to route Eventarc events to Workflows without having an intermediary service.

Integrating Eventarc and Workflows In a previous post, we talked about how to integrate Eventarc and Workflows. Since there was no direct integration between the two services, we had to deploy an intermediary Cloud Run service to receive events from Eventarc and then use the Workflows API to kick off a Workflows execution. Let’s take a look at a concrete example on how this worked.

Creating Eventarc triggers with Terraform

atamel@gmail.com (Mete Atamel) — Fri, 18 Mar 2022 00:00:00 +0000

Terraform is increasingly the preferred tool for building, changing, and versioning infrastructure in Google Cloud and across clouds. In an earlier post, I showed how to create Eventarc triggers using Google Cloud Console or via the command line with gcloud. In this post, I show how to create the same triggers with the google_eventarc_trigger Terraform resource.

See eventarc-samples/terraform on GitHub for the prerequisites and main.tf for full Terraform configuration.

Define a Cloud Run service as an event sink Before you can create a trigger, you need to create a Cloud Run service as an event sink for the trigger. You can use Terraform’s google_cloud_run_service resource to define a Cloud Run service:

Applying a path pattern when filtering in Eventarc

atamel@gmail.com (Mete Atamel) — Wed, 02 Mar 2022 00:00:00 +0000

Eventarc

You can now apply a path pattern when filtering in Eventarc. This is especially useful when you need to filter on resource names beyond exact match. Path pattern syntax allows you to define a regex-like expression that matches events as broadly as you like.

Let’s take a look at a concrete example.

Without path patterns

Let’s say you want to listen for new file creations in a Cloud Storage bucket with an AuditLog trigger.

Building APIs with Cloud Functions and API Gateway

atamel@gmail.com (Mete Atamel) — Thu, 10 Feb 2022 00:00:00 +0000

Building APIs with Cloud Run

If I want to build an API, I usually use Cloud Run. In Cloud Run, you run a container and in that container, you run a web server that handles a base URL in this format:

https://<service-name>-<hash>-<region>.a.run.app

You can then have the web server handle any path under that base URL such as:

https://<service-name>-<hash>-<region>.a.run.app/hello
https://<service-name>-<hash>-<region>.a.run.app/bye

Building APIs with Cloud Functions

In Cloud Functions, you only have access to a function (no web server) and that function can only handle the base path:

Long-running containers with Workflows and Compute Engine

atamel@gmail.com (Mete Atamel) — Wed, 09 Feb 2022 00:00:00 +0000

Sometimes, you need to run a piece of code for hours, days, or even weeks. Cloud Functions and Cloud Run are my default choices to run code. However, they both have limitations on how long a function or container can run. This rules out the idea of executing long-running code in a serverless way.

Thanks to Workflows and Compute Engine, you can have an almost serverless experience with long running code.

Implementing the saga pattern in Workflows

atamel@gmail.com (Mete Atamel) — Sat, 05 Feb 2022 00:00:00 +0000

It’s common to have a separate database for each service in microservices-based architectures. This pattern ensures that the independently designed and deployed microservices remain independent in the data layer as well. But it also introduces a new problem: How do you implement transactions (single units of work, usually made up of multiple operations) that span multiple microservices each with their own local database?

In a traditional monolith architecture, you can rely on ACID transactions (atomicity, consistency, isolation, durability) against a single database. In a microservices architecture, ensuring data consistency across multiple service-specific databases becomes more challenging. You cannot simply rely on local transactions. You need a cross-service transaction strategy. That’s where the saga pattern comes into play.

.NET 6 support in Google Cloud Buildpacks and Cloud Run

atamel@gmail.com (Mete Atamel) — Fri, 04 Feb 2022 00:00:00 +0000

I really like the idea of containers, a reproducible context that our apps can rely on. However, I really dislike having to create a Dockerfile to define my container images. I always need to copy & paste it from somewhere and it takes me some time to get it right.

That’s why I like using Google Cloud Buildpacks to build containers without having to worry about a Dockerfile.

I’m happy to announce that, as of yesterday, Google Cloud Buildpacks now supports .NET 6 (the latest LTS version) apps as well!

Auto-completion for Workflows JSON and YAML on Visual Studio Code

atamel@gmail.com (Mete Atamel) — Fri, 28 Jan 2022 00:00:00 +0000

If you’re like me, you probably use VS Code to author your Workflows JSON or YAML. You also probably expect some kind syntax validation or auto-completion as you work on your workflow. Unfortunately, there’s no VS Code extension for Workflows and Cloud Code for VS Code does not support Workflows.

However, there’s a way to get partial auto-completion for Workflows in VS Code.

VS Code and JSON Schema

VS Code has the ability to display auto-complete suggestions for JSON and YAML files out of the box. It uses JSON Schema Store which hosts JSON Schemas for popular configuration files in JSON and YAML.

Introducing the new Eventarc UI, Cloud Run for Anthos destinations

atamel@gmail.com (Mete Atamel) — Sat, 15 Jan 2022 00:00:00 +0000

December was a busy month for the Eventarc team, who landed a number of features at the end of the year. Let’s take a closer look at some of these new capabilities.

Cloud Storage trigger is GA Back in September, we announced the public preview of Cloud Storage triggers as the preferred way of routing Cloud Storage events to Cloud Run targets. They are now generally available. For more details, see the documentation on how to create a Cloud Storage trigger and check out my previous blog post on Cloud Storage triggers.

Cross-region and cross-project event routing with Eventarc and Pub/Sub

atamel@gmail.com (Mete Atamel) — Thu, 09 Dec 2021 00:00:00 +0000

With event-driven architectures, it’s quite common to read events from a source in one region or project and route them to a destination in another region or another project. Let’s take a look at how you can implement cross-region and cross-project event routing in Google Cloud.

Cross-region event routing is straightforward in Google Cloud, whether you’re using Pub/Sub directly or Eventarc. Pub/Sub routes messages globally. When applications hosted in any region publish messages to a topic, subscribers from any region can pull from that topic. Eventarc enables you to route events across regions by creating a trigger in the region of the event’s source and specifying a destination in a different region. For more details, take a look at my previous blog post on Eventarc locations.

A closer look at locations in Eventarc

atamel@gmail.com (Mete Atamel) — Tue, 26 Oct 2021 00:00:00 +0000

New locations in Eventarc Back in August, we announced more Eventarc locations (17 new regions, as well as 6 new dual-region and multi-region locations to be precise). This takes the total number of locations in Eventarc to more than 30. You can see the full list in the Eventarc locations page or by running gcloud eventarc locations list .

What does location mean in Eventarc? An Eventarc location usually refers to the single region that the Eventarc trigger gets created in. However, depending on the trigger type, the location can be more than a single region:

Trying out source-based deployment in Cloud Run

atamel@gmail.com (Mete Atamel) — Tue, 19 Oct 2021 00:00:00 +0000

Until recently, this is how you deployed code to Cloud Run:

Define your container-based app with a Dockerfile. Build the container image and push it to the Container Registry (typically with Cloud Build). Deploy the container image to Cloud Run. Back in December, we announced the beta release of source-based deployments for Cloud Run. This combines steps 2 and 3 above into a single command. Perhaps more importantly, it also eliminates the need for a Dockerfile for supported language versions.

Analyzing Twitter sentiment with new Workflows processing capabilities

atamel@gmail.com (Mete Atamel) — Sat, 09 Oct 2021 00:00:00 +0000

The Workflows team recently announced the general availability of iteration syntax and connectors!

Iteration syntax supports easier creation and better readability of workflows that process many items. You can use a for loop to iterate through a collection of data in a list or map, and keep track of the current index. If you have a specific range of numeric values to iterate through, you can also use range-based iteration.

Introducing the new Cloud Storage trigger in Eventarc

atamel@gmail.com (Mete Atamel) — Tue, 21 Sep 2021 00:00:00 +0000

Eventarc now supports a new Cloud Storage trigger to receive events from Cloud Storage buckets!

Wait a minute. Didn’t Eventarc already support receiving Cloud Storage events? You’re absolutely right! Eventarc has long supported Cloud Storage events via the Cloud Audit Logs trigger. However, the new Cloud Storage trigger has a number of advantages and it’s now the preferred way of receiving Cloud Storage events. Let’s take a look at the details.

Get notified when an expensive BigQuery job executes using Eventarc and SendGrid

atamel@gmail.com (Mete Atamel) — Tue, 08 Jun 2021 00:00:00 +0000

Events supported by Eventarc

Last week, I put together a list of events supported by Eventarc in our eventarc-samples repo. Thanks to our docs team, this list is now part of our official docs under reference section.

After looking at the full list, I started thinking about some use cases enabled by these events. I want to talk about one of those use cases today: How to get notified when an expensive BigQuery job executes?

Deploying multi-YAML Workflows definitions with Terraform

atamel@gmail.com (Mete Atamel) — Thu, 13 May 2021 00:00:00 +0000

I’m a big fan of using Workflows to orchestrate and automate services running on Google Cloud and beyond. In Workflows, you can define a workflow in a YAML or JSON file and deploy it using gcloud or using Google Cloud Console. These approaches work but a more declarative and arguably better approach is to use Terraform.

Let’s see how to use Terraform to define and deploy workflows and explore options for keeping Terraform configuration files more manageable.

Introducing new connectors for Workflows

atamel@gmail.com (Mete Atamel) — Tue, 27 Apr 2021 00:00:00 +0000

Workflows is a service to orchestrate not only Google Cloud services, such as Cloud Functions, Cloud Run, or machine learning APIs, but also external services. As you might expect from an orchestrator, Workflows allows you to define the flow of your business logic, as steps, in a YAML or JSON definition language, and provides an execution API and UI to trigger workflow executions. You can read more about the benefits of Workflows in our previous article.

Choosing the right orchestrator in Google Cloud

atamel@gmail.com (Mete Atamel) — Thu, 22 Apr 2021 00:00:00 +0000

What is orchestration? Orchestration often refers to the automated configuration, coordination, and management of computer systems and services.

In the context of service-oriented architectures, orchestration can range from simply executing a single service at a specific time and day, to a more sophisticated approach of automating and monitoring multiple services over longer periods of time, with the ability to react and handle failures as they crop up.

In the data engineering context, orchestration is central to coordinating the services and workflows that prepare, ingest, and transform data. It can go beyond data processing and also involve a workflow to train a machine learning (ML) model from the data.

Three ways of receiving events in Cloud Run

atamel@gmail.com (Mete Atamel) — Fri, 12 Mar 2021 00:00:00 +0000

Cloud Run and Eventarc is a great combination for building event-driven services with different event routing options. There are two trigger types (Audit Logs and Pub/Sub) to choose from in Eventarc. Eventarc uses Pub/Sub as its underlying transport layer and provides convenience and standardization on top of it. If you wanted to, you could skip Eventarc and read messages directly from Pub/Sub in Cloud Run.

This blog post details three ways of receiving events in Cloud Run and provides a decision framework on how to choose.

Demystifying event filters in Eventarc

atamel@gmail.com (Mete Atamel) — Tue, 02 Mar 2021 00:00:00 +0000

Eventarc enables you to read events from Google Cloud sources (via its Audit Logs integration) and custom sources (via its Pub/Sub integration) and then route them to Cloud Run services.

https://storage.googleapis.com/gweb-cloudblog-publish/images/eventarc-architecture.max-2000x2000.png The event routing rules are defined with a trigger. In a trigger, you specify the right event filters such as service name, method name, resource (which effectively defines the event source) and the target of the events (which can only be a Cloud Run service as of today).

Orchestrating the Pic-a-Daily serverless app with Workflows

atamel@gmail.com (Mete Atamel) — Sat, 13 Feb 2021 00:00:00 +0000

Over the past year, we (Mete and Guillaume) have developed a picture sharing application, named Pic-a-Daily, to showcase Google Cloud serverless technologies such as Cloud Functions, App Engine, and Cloud Run. Into the mix, we’ve thrown a pinch of Pub/Sub for interservice communication, a zest of Firestore for storing picture metadata, and a touch of machine learning for a little bit of magic.

https://storage.googleapis.com/gweb-cloudblog-publish/images/1_Shqfx7L.max-1400x1400.png We also created a hands-on workshop to build the application, and slides with explanations of the technologies used. The workshop consists of codelabs that you can complete at your own pace. All the code is open source and available in a GitHub repository.

Eventarc brings eventing to Cloud Run and is now GA

atamel@gmail.com (Mete Atamel) — Fri, 29 Jan 2021 00:00:00 +0000

Back in October, we announced the public preview of Eventarc, as new eventing functionality that lets developers route events to Cloud Run services. In a previous post, we outlined more benefits of Eventarc: a unified eventing experience in Google Cloud, centralized event routing, consistency with eventing format, libraries and an ambitious long term vision.

Today, we’re happy to announce that Eventarc is now generally available. Developers can focus on writing code to handle events, while Eventarc takes care of the details of event ingestion, delivery, security, observability, and error handling.

Eventarc - A unified eventing experience in Google Cloud

atamel@gmail.com (Mete Atamel) — Sat, 16 Jan 2021 00:00:00 +0000

I recently talked about orchestration versus choreography in connecting microservices and introduced Workflows for use cases that can benefit from a central orchestrator. I also mentioned Eventarc and Pub/Sub in the choreography camp for more loosely coupled event-driven architectures.

In this blog post, I talk more about the unified eventing experience by Eventarc.

What is Eventarc? We announced Eventarc back in October as a new eventing functionality that enables you to send events to Cloud Run from more than 60 Google Cloud sources. It works by reading Audit Logs from various sources and sending them to Cloud Run services as events in CloudEvents format. It can also read events from Pub/Sub topics for custom applications.

Better service orchestration with Workflows

atamel@gmail.com (Mete Atamel) — Wed, 02 Dec 2020 00:00:00 +0000

Going from a single monolithic application to a set of small, independent microservices has clear benefits. Microservices enable reusability, make it easier to change and scale apps on demand. At the same time, they introduce new challenges. No longer is there a single monolith with all the business logic neatly contained and services communicating with simple method calls. In the microservices world, communication has to go over the wire with REST or some kind of eventing mechanism and you need to find a way to get independent microservices to work toward a common goal.

Introducing Eventarc in Pic-a-Daily Serverless Workshop

atamel@gmail.com (Mete Atamel) — Mon, 30 Nov 2020 00:00:00 +0000

Pic-a-Daily Serverless Workshop

As you might know, Guillaume Larforge and I have a Pic-a-Daily Serverless Workshop. In this workshop, we build a picture sharing application using Google Cloud serverless technologies such as Cloud Functions, App Engine, Cloud Run and more.

Pic-a-Daily Serverless Workshop

We recently added a new service to the workshop. In this blog post, I want to talk about the new service. I also want to talk about Eventarc and how it helped us to get events to the new service.

.NET 5.0 on Google Cloud

atamel@gmail.com (Mete Atamel) — Fri, 20 Nov 2020 00:00:00 +0000

.NET 5.0 was released just a few days ago with many new features, improvements, C# 9 support, F# 5 support, and more. .NET 5.0 is the first release of the unified .NET vision that was announced last year. Going forward, there will be just one .NET targeting Windows, Linux, macOS, and more.

Google Cloud already has support for different versions of .NET. You can run traditional Windows based .NET apps on Windows Servers in Compute Engine or on Windows Containers in Google Kubernetes Engine (GKE). For modern Linux based containerized .NET apps, there’s more choice with App Engine (Flex), GKE and my favorite Cloud Run. Not to mention, the .NET Core 3.1 support in Cloud Functions is currently in preview for serverless .NET functions.

Knative v0.18.0 update

atamel@gmail.com (Mete Atamel) — Mon, 12 Oct 2020 00:00:00 +0000

I got around to updating my Knative Tutorial from Knative v0.16.0 to the latest Knative Serving v0.18.0 release and Knative Eventing v0.18.1 release.

In this short blog post, I want to outline a couple of minor issues I encountered during my upgrade. Note that I skipped v0.17 altogether, some of these changes might have happened in that release.

Istio Installation

The biggest change I encountered is how Istio is installed for Knative. In previous releases, I simply pointed to the yaml files in the latest Istio version in third_party folder of Knative Serving.

Events for Cloud Run for Anthos >= Knative Eventing on Kubernetes

atamel@gmail.com (Mete Atamel) — Thu, 08 Oct 2020 00:00:00 +0000

Introduction

We recently announced a new feature, Events for Cloud Run for Anthos, to build event driven systems on Google Kubernetes Engine (GKE). In the announcement, we also stated that the solution is based on open-source Knative.

In this blog post, I want to further explain the relationship between this new feature and Knative. I also want to convince you that our solution is an easier way to deploy Knative compliant event consuming services on Google Cloud.

Cloud Run for Anthos brings eventing to your Kubernetes microservices

atamel@gmail.com (Mete Atamel) — Thu, 24 Sep 2020 00:00:00 +0000

Building microservices on Google Kubernetes Engine (GKE) provides you with maximum flexibility to build your applications, while still benefiting from the scale and toolset that Google Cloud has to offer. But with great flexibility comes great responsibility. Orchestrating microservices can be difficult, requiring non-trivial implementation, customization, and maintenance of messaging systems.

Cloud Run for Anthos now includes an events feature that allows you to easily build event-driven systems on Google Cloud. Now in beta, Cloud Run for Anthos’ event feature assumes responsibility for the implementation and management of eventing infrastructure, so you don’t have to.

A first look at serverless orchestration with Workflows

atamel@gmail.com (Mete Atamel) — Tue, 08 Sep 2020 00:00:00 +0000

Challenges in connecting services

When I think about my recent projects, I probably spent half of my time coding new services and the other half in connecting services. Service A calling Service B, or Service C calling an external service and using the result to feed into another Service D.

Connecting services is one of those things that ‘should be easy’ but in reality, it takes a lot of time and effort. You need to figure out a common connection format for services to use, make the connection, parse the results, and pass the results on. I’m not even mentioning error handling, retries and all those production readiness type features that you ultimately need to do.

Scheduled serverless dbt + BigQuery service

atamel@gmail.com (Mete Atamel) — Wed, 29 Jul 2020 00:00:00 +0000

My colleague Felipe Hoffa recently published a blog post titled Get started with BigQuery and dbt, the easy way. More specifically, he showed how to install dbt in Google Cloud Shell, configure it and manually run it to create a temporary dataset in BigQuery. This is great for testing dbt + BigQuery but how do you run this kind of setup in production?

dbt documentation states that Running dbt in production simply means setting up a system to run a dbt job on a schedule, rather than running dbt commands manually from the command line.

Knative v0.16.0 update

atamel@gmail.com (Mete Atamel) — Wed, 22 Jul 2020 00:00:00 +0000

I finally got around to updating my Knative Tutorial from Knative v0.14.0 to the latest Knative v0.16.0 release. Since I skipped v0.15.0, I’m not sure which changes are due to v0.15.0 vs. v0.16.0. Regardless, there have been some notable changes that I want to outline in this blog post. This is not meant to be an exhaustive list. Feel free to let me know in the comments if there are other notable changes that I should be aware of.

Google Cloud Functions on .NET

atamel@gmail.com (Mete Atamel) — Tue, 14 Jul 2020 00:00:00 +0000

.NET for Google Cloud Functions (Alpha)

I spoke at many .NET conferences over the last 3-4 years and one of the top requests I always received was: When will .NET be supported on Cloud Functions?

Unfortunately, I didn’t have a good answer for a while. That all changed last month with the following tweet from Jon Skeet from our C# team:

I'm thrilled that .NET support is coming to Google Cloud Functions, along with the .NET Functions Framework. Sign up for the public alpha at https://t.co/nASIACFCrg

.NET Core 3.1 updates in Cloud Shell and App Engine flexible environment

atamel@gmail.com (Mete Atamel) — Mon, 29 Jun 2020 00:00:00 +0000

.NET Core 3.1 updates on Google Cloud

.NET Core 3.1 was released on December 3rd, 2019 and is a LTS release, supported for three years.

In Google Cloud, you could already deploy .NET Core 3.1 containers in Cloud Run (see cloud-run-dotnetcore-31) and also in App Engine flexible environment with a custom runtime.

We recently extended .NET Core 3.1 support in a couple of ways:

Cloud Shell now supports .NET Core 3.1.
App Engine flexible environment runtime now supports .NET Core 3.1.

.NET Core 3.1 in Cloud Shell

Inside Cloud Shell, you can see the latest 3.1.301 version:

Daily COVID-19 cases notification Pipeline with Knative Eventing, BigQuery, Matplotlib and SendGrid

atamel@gmail.com (Mete Atamel) — Mon, 15 Jun 2020 00:00:00 +0000

Motivation

When I started working from home in mid-March, I was totally obsessed with COVID-19 news. I was constantly checking number of cases and news from the UK (where I currently live) and from Cyprus (where I’m originally from). It took me a couple of weeks to realize how unproductive this was. I started limiting myself to check for news once a day. This definitely helped me to regain sanity and productivity but it was manual.

Event-Driven Image Processing Pipeline with Knative Eventing

atamel@gmail.com (Mete Atamel) — Fri, 05 Jun 2020 00:00:00 +0000

In this post, I want to talk about an event-driven image processing pipeline that I built recently using Knative Eventing. Along the way, I’ll tell you about event sources, custom events and other components provided by Knative that simply development of event-driven architectures.

Requirements

Let’s first talk about the basic requirements I had for the image processing pipeline:

Users upload files to an input bucket and get processed images in an output bucket.
Uploaded images are filtered (eg. no adult or violent images) before sending through the pipeline.
Pipeline can contain any number of processing services that can be added or removed as needed. For the initial pipeline, I decided to go with 3 services: resizer, watermarker, and labeler. The resizer will resize large images. The watermarker will add a watermark to resized images and the labeler will extract information about images (labels) and save it.

Requirement #3 is especially important. I wanted to be able to add services to the pipeline as I need them or create multiple pipelines with different services chained together.

Workload Identity Authentication for Knative v0.14.0 on GKE

atamel@gmail.com (Mete Atamel) — Wed, 20 May 2020 00:00:00 +0000

If you ever used Knative on Google Cloud, you must have heard of Knative-GCP project. As the name suggests, Knative-GCP project provides a number of sources such as CloudPubSubSource, CloudStorageSource, CloudSchedulerSource and more to help reading various Google Cloud sources into your Knative cluster.

I recently updated my Knative Tutorial to use the latest Knative Eventing release v0.14.2 and its corresponding Knative-GCP release v0.14.0. I ran into a weird authentication problem that I want to outline here.

Knative Eventing Delivery Methods

atamel@gmail.com (Mete Atamel) — Thu, 12 Mar 2020 16:06:51 +0000

Knative Eventing docs are a little confusing when it comes to different event delivery methods it supports. It talks about event brokers and triggers and it also talks about sources, services, channels, and subscriptions. What to use and when? It’s not clear. Let’s break it down.

Delivery methods

There are 3 distinct methods in Knative:

Simple delivery
Complex delivery with optional reply
Broker and Trigger delivery

Broker and Trigger delivery is what you should care about most of the time. However, the simple and complex delivery have been in Knative for a while and still good to know for what’s happening under the covers.

An app modernization story — Part 4 (Serverless Microservices)

atamel@gmail.com (Mete Atamel) — Mon, 24 Feb 2020 13:51:54 +0000

In part 3 of the blog series, I talked about how we transformed our Windows-only .NET Framework app to a containerized multi-platform .NET Core app.

This removed our dependency on Windows and enabled us to deploy to Linux-based platforms such as App Engine (Flex). On the other hand, the app still ran on VMs, it was billed per second even if nobody used it, deployments were slow and most importantly, it was a single monolith that was deployed and scaled as a single unit.

An app modernization story — Part 3 (Containerize & Redeploy)

atamel@gmail.com (Mete Atamel) — Wed, 12 Feb 2020 11:39:29 +0000

In part 1, I talked about the initial app and its challenges. In part 2, I talked about the lift & shift to the cloud with some unexpected benefits. In this part 3 of the series, I’ll talk about how we transformed our Windows-only .NET Framework app to a containerized multi-platform .NET Core app and the huge benefits we got along the way.

Why?

The initial Windows VM based cloud setup served us well with minimal issues about roughly 2 years (from early 2017 to early 2019). In early 2019, we wanted to revisit the architecture again. This was mainly driven by the advances in the tech scene namely:

An app modernization story — Part 2 (Lift & Shift)

atamel@gmail.com (Mete Atamel) — Thu, 06 Feb 2020 09:29:04 +0000

In part 1 of app modernization series, I introduced a simple news aggregator and some of the challenges in its initial architecture. In part 2, I’ll talk about the journey to the cloud and some unexpected benefits and learnings along the way.

Why Cloud?

The initial backend had many issues that I outlined in part 1. After about 1 year, in late 2016, we decided to look into moving it to a more stable home. Our main goal was to improve resiliency of the app, as the IIS host kept crashing, but we didn’t want to rewrite or re-architecture the app in a major way. Around the same time, I started working at Google and was learning all about Google Cloud. We decided to give it a try and see what it took to move the app there.

An app modernization story — Part 1 (Prototype)

atamel@gmail.com (Mete Atamel) — Fri, 31 Jan 2020 15:02:40 +0000

We all have apps running some “legacy code” in some “legacy way”. The term “legacy” means different things in different projects but we know when we see it and we want to get the time to modernize those apps in some way.

I recently went through the latest phase of modernization of a legacy app. Even though it’s a relatively small app, it thought me a number of lessons that’s worth sharing.

Knative v0.12.0 update

atamel@gmail.com (Mete Atamel) — Mon, 27 Jan 2020 15:07:35 +0000

It’s hard to keep with Knative releases with a release every 6 weeks. I finally managed to update my Knative Tutorial for the latest Knative v0.12.0. In this blog post, I want to outline some of the differences I’ve observed.

Knative Serving

Knative Serving has been pretty stable in the recent releases and Knative Serving v0.12.0 is no exception. I didn’t need to update my tutorial specifically for this release.

Knative Eventing

Knative Eventing v0.12.0 changed the default yaml for Knative Eventing bundles. Now, they are under eventing.yaml (previously, it was release.yaml) and this is the yaml you need to point to install eventing. This makes sense as it’s more consistent with Knative Serving and its serving.yaml.

How to properly install Knative on GKE

atamel@gmail.com (Mete Atamel) — Mon, 13 Jan 2020 16:50:06 +0000

The default Knative Installation instructions for Google Kubernete Engine (GKE) is problematic (see bug 2266). In this post, I want to outline what the problem is, tell you what I do, and also provide you the scripts that work for me until a proper solution is implemented either in gcloud or Knative.

The problem

The default Knative Installation instructions tell you to create a GKE cluster as follows:

gcloud beta container clusters create $CLUSTER_NAME \
 --addons=HorizontalPodAutoscaling,HttpLoadBalancing,Istio \
 --machine-type=n1-standard-4 \
 --cluster-version=latest --zone=$CLUSTER_ZONE \
 --enable-stackdriver-kubernetes --enable-ip-alias \
 --enable-autoscaling --min-nodes=1 --max-nodes=10 \
 --enable-autorepair \
 --scopes cloud-platform

Notice the Istio add-on. This command creates a Kubernetes cluster with Istio already installed. This is good because Istio is a dependency of Knative but keep reading.

Cluster local issue with Knative Eventing v0.9.0

atamel@gmail.com (Mete Atamel) — Mon, 14 Oct 2019 14:56:33 +0000

In my previous post, I talked about Knative v0.9.0 and some of the eventing changes in the latest release. I’ve been playing with Knative v0.9.0 since then to read Google Cloud Pub/Sub messages using PullSubscription and I ran into a rather fundamental issue that baffled me for a while. I’d like to outline the problem and the solution here, just in case it’s useful to others.

Knative Services as eventing sinks

In my PullSubscription, I could define Kubernetes Services as event sinks as follows:

How to deploy a Windows container on Google Kubernetes Engine

atamel@gmail.com (Mete Atamel) — Sat, 28 Sep 2019 00:00:00 +0000

Many people who run Windows containers want to use a container management platform like Kubernetes for resiliency and scalability. In a previous post, we showed you how to run an IIS site inside a Windows container deployed to Windows Server 2019 running on Compute Engine. That’s a good start, but you can now also run Windows containers on Google Kubernetes Engine (GKE).

Support for Windows containers in Kubernetes was announced earlier in the year with version 1.14, followed by GKE announcement on the same. You can sign up for early access and start testing out Windows containers on GKE.

Knative v0.9.0

atamel@gmail.com (Mete Atamel) — Thu, 26 Sep 2019 13:56:36 +0000

Knative has been evolving pretty quickly. There’s a new release roughly every 6 weeks with significant changes in each release. Knative v0.7.0 was all about changes in Knative Serving (my post). Knative v0.8.0 was about deprecation of Knative Build in favor of Tekton Pipelines (my other post).

Knative Serving v0.9.0 and Eventing v0.9.0 have been released a little over a week ago. In Serving, there’s a v1 API and a number of improvements on autoscaling and cold starts. In Eventing, the way events are read changed quite a bit. I want to outline some of these changes here.

How to deploy a Windows container on Google Compute Engine

atamel@gmail.com (Mete Atamel) — Sat, 21 Sep 2019 00:00:00 +0000

Last year, we published a blog post and demonstrated how to deploy a Windows container running Windows Server 2016 on Google Compute Engine. Since then, there have been a number of important developments. First, Microsoft announced the availability of Windows Server 2019. Second, Kubernetes 1.14 was released with support for Windows nodes and Windows containers.

Supporting Windows workloads and helping you modernize your apps using containers and Kubernetes is one of our top priorities at Google Cloud. Soon after the Microsoft and Kubernetes announcements, we added support for Windows Server 2019 in Compute Engine and Windows containers in Google Kubernetes Engine (GKE).

Migrating from Knative Build to Tekton Pipelines

atamel@gmail.com (Mete Atamel) — Wed, 28 Aug 2019 10:27:47 +0000

Knative 0.8.0 and Build Deprecation

Knative 0.8.0 came out a couple of weeks ago with a number of fixes and improvements. One of the biggest changes in 0.8.0 is that Knative Build is now deprecated according to docs:

Knative Installation docs also only include Knative Serving and Eventing without mentioning Build:

kubectl apply 
\-f https://github.com/knative/serving/releases/download/v0.8.0/serving.yaml \\ 
\-f https://github.com/knative/eventing/releases/download/v0.8.0/release.yaml \\ 
\-f https://github.com/knative/serving/releases/download/v0.8.0/monitoring.yaml

Good to know but there’s no explanation on why Knative Build was deprecated and any guidance on what is the replacement, if any. After a little bit of research, I have more information on deprecation and also a migration path that I’d like to share in this post.

Migrating from Kubernetes Deployment to Knative Serving

atamel@gmail.com (Mete Atamel) — Wed, 31 Jul 2019 02:18:22 +0000

When I talk about Knative, I often get questions on how to migrate an app from Kubernetes Deployment (sometimes with Istio) to Knative and what are the differences between the two setups.

First of all, everything you can do with a Knative Service, you can probably do with a pure Kubernetes + Istio setup and the right configuration. However, it’ll be much harder to get right. The whole point of Knative is to simplify and abstract away the details of Kubernetes and Istio for you.

Serverless gRPC + ASP.NET Core with Knative

atamel@gmail.com (Mete Atamel) — Wed, 24 Jul 2019 16:29:17 +0000

I was recently going through the ASP.NET Core updates in .NET Core 3.0 Preview 3 post, this section got my attention: gRPC template.

Apparently, .NET Core 3.0 got a new gRPC template for easily building gRPC services with ASP.NET Core. I tested gRPC and .NET before and I have some samples in my grpc-samples-dotnet repo. Even though gRPC and .NET worked before, it wasn’t that straightforward to setup. I was curious to try out the new gRPC template and see how it helped.

Knative Serving 0.7

atamel@gmail.com (Mete Atamel) — Mon, 01 Jul 2019 11:13:59 +0000

As you might have heard, Knative 0.7 was out last week. One of the notable changes in this release is that Knative Serving API progressed from v1alpha to v1beta. While you can still use the old v1alpha1 API, if you want to update to v1beta, you need to rewrite your Knative service definition files. The new API also allows named revisions, silent latest deploys and a better traffic splitting configuration. In this post, I want to outline some of these changes.

Cloud Run as an internal async worker

atamel@gmail.com (Mete Atamel) — Tue, 28 May 2019 12:14:20 +0000

Cloud Pub/Sub + Cloud Run

Introduction

If you’ve heard of Cloud Run, you already know that it’s great for spinning public endpoints inside stateless containers to handle HTTP request/reply type of workloads. And the best part is that you only pay for the duration of the request!

However, HTTP request/reply handling is not the only use-case for Cloud Run. Combined with Cloud Pub/Sub, Cloud Run is very well suited for internal async worker type use-cases because:

Knative + Buildpacks: Source code to container image without Dockerfile

atamel@gmail.com (Mete Atamel) — Thu, 16 May 2019 00:02:49 +0000

I previously talked about Knative Build and how it enables you to go from source code to a container image in a repository. You can write your Build from scratch or you can rely on many of the BuildTemplates Knative already provides. For example, in my Knative Tutorial, I show how to install Kaniko BuildTemplate and use Kaniko to build container images.

You normally need to write a Dockerfile, so Knative Build (or Kaniko to be more precise) knows how to build the container image. Wouldn’t it be great if there was a an automatic way to build your app without having to define a Dockerfile ? Well, there is!

Knative to Cloud Run

atamel@gmail.com (Mete Atamel) — Tue, 07 May 2019 15:47:44 +0000

Cloud Run

In my Hands on Knative series (part 1, part 2, part 3), I showed how to use Knative Serving, Eventing and Build on any Kubernetes cluster anywhere. This is great for portability but with that portability comes the overhead of creating and managing a Kubernetes cluster. Not to mention the complexity of Istio which is a dependency of Knative.

Google Kubernetes Engine (GKE) helps with managing the Kubernetes cluster a little but you still need to worry about all the bells and whistles of a Kubernetes cluster. Wouldn’t it be great to have the Knative Serving experience without having to worry about the underlying infrastructure? Well, you can with Cloud Run!

Professional Cloud Architect Certification

atamel@gmail.com (Mete Atamel) — Mon, 04 Mar 2019 09:59:54 +0000

TL;DR: I recently went through the preparation and exam of Google Cloud’s Professional Cloud Architect Certification. It was great learning experience and I highly recommend it. You can register here to get certified yourself!

Why?

As you might know, I’m a Googler and a Developer Advocate for Google Cloud. Why do I want to be certified by Google Cloud when I already work at Google and know a great deal about Google Cloud? I had 2 main motivations:

Hands on Knative — Part 3

atamel@gmail.com (Mete Atamel) — Tue, 19 Feb 2019 13:43:11 +0000

In Part 1, I talked about Knative Serving for rapid deployment and autoscaling of serverless containers. In Part 2, I talked about how to connect services in a loosely coupled way with Knative Eventing.

In third and last part of the series, I want to talk about Knative Build and show a few examples from my Knative Tutorial.

What is Knative Build?

Knative Build basically allows you to go from source code to a container image in a registry. For example, you can write a build to obtain your source code from a repository, build a container image, push that image to a registry and then run that image, all within the Kubernetes cluster.

Hands on Knative — Part 2

atamel@gmail.com (Mete Atamel) — Mon, 11 Feb 2019 18:29:59 +0000

In my previous post, I talked about Knative Serving for rapid deployment and autoscaling of serverless containers. Knative Serving is great if you want your services to be synchronously triggered by HTTP calls. However, in the serverless microservices world, asynchronous triggers are more common and useful. That’s when Knative Eventing comes into play.

In this second part of Hands on Knative series, I want to introduce Knative Eventing and show some examples from my Knative Tutorial on how to integrate it with various services.

Hands on Knative — Part 1

atamel@gmail.com (Mete Atamel) — Mon, 04 Feb 2019 14:56:53 +0000

I’ve been looking into Knative recently. In this 3-part blog series, I want to explain my learnings and show some hands on examples from the Knative Tutorial that I published on GitHub.

What is Knative anyway?

Knative is a collection of open source building blocks for serverless containers running on Kubernetes.

At this point, you might be wondering: “Kubernetes, serverless, what’s going on?” But, when you think about it, it makes sense. Kubernetes is hugely popular container management platform. Serverless is how application developers want to run their code. Knative brings the two worlds together with a set of building blocks.

Application metrics in Istio

atamel@gmail.com (Mete Atamel) — Mon, 07 Jan 2019 10:51:38 +0000

The default metrics sent by Istio are useful to get an idea on how the traffic flows in your cluster. However, to understand how your application behaves, you also need application metrics.

Prometheus has client libraries that you can use to instrument your application and send those metrics. This is good but it raises some questions:

Where do you collect those metrics?
Do you use Istio’s Prometheus or set up your own Prometheus?
If you use Istio’s Prometheus, what configuration do you need to get those metrics scraped?

Let’s try to answer these questions.

Istio Routing Basics

atamel@gmail.com (Mete Atamel) — Fri, 02 Nov 2018 11:22:44 +0000

When learning a new technology like Istio, it’s always a good idea to take a look at sample apps. Istio repo has a few sample apps but they fall short in various ways. BookInfo is covered in the docs and it is a good first step. However, it is too verbose with too many services for me and the docs seem to focus on managing the BookInfo app, rather than building it from ground up. There’s a smaller helloworld sample but it’s more about autoscaling than anything else.

Dialogflow fulfillment with C# and App Engine

atamel@gmail.com (Mete Atamel) — Mon, 24 Sep 2018 13:06:27 +0000

Dialogflow is a developer platform for building voice or text-based conversational apps on a number of platforms such as Google Assistant, Facebook Messenger, Twilio, Skype and more. Earlier this year, we used Dialogflow to build a Google Assistant app and extended it to use the power of Google Cloud. You can read more about it on Google Cloud blog here, see the app code on GitHub here and one of my talk videos about the app is here.

Istio 101 (1.0) on GKE

atamel@gmail.com (Mete Atamel) — Mon, 06 Aug 2018 18:36:00 +0000

Istio 1.0 is finally announced! In this post, I updated my previous Istio 101 post with Istio 1.0 specific instructions. Most of the instructions are the same but with a few minor differences about where things live (folder names/locations changed) and also most commands now default to kubectl instead of istioctl.

For those of you who haven’t read my Istio 101 post, I show how to install Istio 1.0 on Google Kubernetes Engine (GKE), deploy the sample BookInfo app and show some of the add-ons and traffic routing.

Google Home meets .NET containers using Dialogflow

atamel@gmail.com (Mete Atamel) — Fri, 13 Jul 2018 00:00:00 +0000

I use my Google Home all the time to check the weather before leaving home, set up alarms, listen to music, but I never considered writing an app for it. What does it take to write an app for the Google Home assistant? And can we make it smarter by leveraging Google Cloud? Those were the questions that my colleague Chris Bacon, and I were thinking about when we decided to build a demo for a conference talk.

.NET Days in Zurich, Shift Conf in Split

atamel@gmail.com (Mete Atamel) — Mon, 11 Jun 2018 16:00:55 +0000

Last week was a quite interesting week in terms of travel. First I got to visit Zurich again after a while for .NET Day and then I got to visit the Croatian coastal town Split for the first time for Shift Conference.

.NET Days in Zurich

When I used to work at Adobe, part of my team was based in Basel, Switzerland. As a result, I used to visit Basel, Zurich and other Swiss cities quite often. Since I left Adobe, I visited Switzerland only once 2 years ago. I was naturally excited to visit Zurich again for .NET Day.

Istio 101 (0.8.0) on GKE

atamel@gmail.com (Mete Atamel) — Thu, 07 Jun 2018 07:29:47 +0000

In one of my previous posts, I showed how to install Istio on minikube and deploy the sample BookInfo app. A new Istio version is out (0.8.0) with a lot of changes, especially changes on traffic management, which made my steps in the previous post a little obsolete.

In this post, I want to show how to install Istio 0.8.0 on Google Kubernetes Engine (GKE), deploy the sample BookInfo app and show some of the add-ons and traffic routing.

Codemotion in Amsterdam, Devoxx in London

atamel@gmail.com (Mete Atamel) — Tue, 29 May 2018 08:32:21 +0000

After my trip in Istanbul, I visited my parents in Nicosia, Cyprus for a long weekend. Then, I stopped by in Amsterdam for Codemotion before coming back to London for Devoxx 4 cities in 4 countries in 1 week was exhausting but also a lot of fun in many ways.

Codemotion Amsterdam

Amsterdam is almost a second home to me nowadays. There’s a great tech scene and a lot of tech events throughout the year, as a result, I end up visiting Amsterdam at least 2–3 times a year.

Istanbul: The city where the East and the West meet

atamel@gmail.com (Mete Atamel) — Sun, 20 May 2018 09:33:47 +0000

Istanbul is one of those crazy dynamic cities with friendly people, amazing history, great shopping and above all, a food heaven. Naturally, I was excited to be back for Java Day Istanbul conference.

I came a day early to meet with a partner and visit a customer. They had lots of questions on Kubernetes and hybrid-cloud. It was quite useful for me to hear about their challenges about moving to the cloud and propose some solutions.

Manchester after 20 years

atamel@gmail.com (Mete Atamel) — Fri, 11 May 2018 15:00:40 +0000

After my time in Beijing, I flew back to the UK but instead of London, I went to Manchester for IPExpo conference. The first time I visited Manchester was 20 years ago. I was a 15 year old high school kid and I visited my great aunt and uncle one summer with my sister. I remember I had such a good time back then.

Unfortunately, I never had a chance to visit Manchester again and it was quite nostalgic for me to be back. I was hoping that I would remember Manchester a little bit but to my surprise, it was like a brand new city to me.

First time in China

atamel@gmail.com (Mete Atamel) — Tue, 08 May 2018 16:58:02 +0000

Visiting a new country is always extra special for me and a couple of weeks ago, I got to do just that and visited Beijing, China for the first time.

After TDC in Floripa, I flew to Beijing for QCon conference and for a Google Developer Group (GDG) meetup. It was the first time for me in China (my 48th country!) and first time speaking at QCon, so I was naturally excited. I didn’t know what to expect in Beijing but I was pleasantly surprised. Beijing is a modern city with good public transportation and interesting sites to visit. I got the feeling that it’s also very international with many expats, definitely more than I expected. I visited the iconic sites like Tiananmen Square and the Great Wall of China. I also visited Google’s Beijing office (my 35th Google office visit!)

Trip Report: TDC in Florianópolis

atamel@gmail.com (Mete Atamel) — Wed, 25 Apr 2018 16:24:51 +0000

Last week, I was in my favorite country, Brazil, for The Developer Conference (TDC) in Florianópolis (aka Floripa). I went to Brazil for the first time last July. Since then, I’ve been there 3 more times and I gradually fell in love with it. People are friendly, their BBQ is amazing, scenery is beautiful. I always have a good time in Brazil and this time wasn’t an exception.

In all previous times, I was mainly in Sao Paulo for a conference followed by a short trip to Rio (my favorite city!) for myself. This time, I went to Florianópolis which is a city to the south of Sao Paulo. It has a similar feeling as Rio (i.e. beach town) but smaller and felt safer than Rio. It had amazing views of mountains and sea, great food and friendly people, as always the case with Brazil.

Istio 101 with Minikube

atamel@gmail.com (Mete Atamel) — Tue, 24 Apr 2018 05:44:15 +0000

As part of my Istio 101 talk, I like to show demos locally (because conference Wifi can be unreliable) and Minikube is perfect for this. Minikube gives you a local Kubernetes cluster on top of which you can install Istio.

In this post, I want to show how to do Istio 101 on Minikube. More specifically, I will show how to install Istio, deploy a sample application, install add-ons like Prometheus, Grafana, Zipkin, ServiceGraph and change traffic routes dynamically.

Trip Report: Codemotion in Rome

atamel@gmail.com (Mete Atamel) — Thu, 19 Apr 2018 16:32:23 +0000

Last week, I was in one of my favorite cities, Rome, for Codemotion conference. There are many cities to see in the world and normally, I do not like to revisit cities that I’ve been before. However, Rome is a great exception. It was my fifth visit there over the years and it was still as exciting as the first time. I also found out that Google has a small office in Rome, so I paid a quick visit next morning before attending the conference.

How to run Windows Containers on Compute Engine

atamel@gmail.com (Mete Atamel) — Tue, 03 Apr 2018 00:00:00 +0000

Container virtualization is a rapidly evolving technology that can simplify how you deploy and manage distributed applications. When people discuss containers, they usually mean Linux-based containers. This makes sense, because native Linux kernel features like cgroups introduced the idea of resource isolation, eventually leading to containers as we know them today.

For a long time, you could only containerize Linux processes, but Microsoft introduced support for Windows-based containers in Windows Server 2016 and Windows 10. With this, you can now take an existing Windows application, containerize it using Docker, and run it as an isolated container on Windows. Microsoft supports two flavors of Windows containers: Windows Server and Hyper-V. You can build Windows containers on either the microsoft/windowsservercore and microsoft/nanoserver base images. You can read more about Windows containers in the Microsoft Windows containers documentation.

Istio + Kubernetes on Windows

atamel@gmail.com (Mete Atamel) — Mon, 19 Feb 2018 09:31:09 +0000

I’ve been recently looking into Istio, an open platform to connect and manage microservices. After Containers and Kubernetes, I believe that Istio is the next step in our microservices journey where we standardize on tools and methods on how to manage and secure microservices. Naturally, I was very excited to get my hands on Istio.

While setting up Istio on Google Kubernetes Engine (GKE) is pretty straightforward, it’s always useful to have a local setup for debugging and testing. I specifically wanted to setup Istio on my local Minikube Kubernetes cluster on my Windows machine. I ran into a few minor issues that I want to outline here in case it is useful to someone out there.

Minikube on Windows

atamel@gmail.com (Mete Atamel) — Wed, 14 Feb 2018 05:16:34 +0000

When I’m playing with Kubernetes, I usually get a cluster from Google Kubernetes Engine (GKE) because it’s literally a single gcloud command to get a Kubernetes cluster up and running on GKE. It is sometimes useful though to have a Kubernetes cluster running locally for testing and debugging. Minikube is perfect for this.

Minikube runs a single-node Kubernetes cluster inside a VM on your laptop. There are instructions on how to install it on Linux, Mac and Windows. Unfortunately, instructions for Windows is a little lacking, so I want to document how I got Minikube up and running on my Windows 10 machine.

Little Mermaid and the Balkans

atamel@gmail.com (Mete Atamel) — Mon, 30 Oct 2017 19:09:46 +0000

I don’t get to visit this many new places in this short amount of time usually but last week I got to visit 4 cities in 4 countries. The amazing thing was that I had never been to any of these cities or countries before!

My journey started in Copenhagen, Denmark on Monday. I had been in all countries around Denmark but not in Denmark itself, so I was happy to finally add Denmark to the list of visited countries. I had to work on Monday, so I paid a visit the Google office in Copenhagen. This was my the 27th Google office I ever visited 🙂

Ada Lovelace Day in London, Unter den Linden in Berlin and DevFest in beautiful Lviv

atamel@gmail.com (Mete Atamel) — Mon, 16 Oct 2017 20:38:30 +0000

October 10 was Ada Lovelace Day, a special day to celebrate women in science, technology, engineering and maths. Unfortunately, there are not enough women in software engineering and technology in general. Programs like Women Techmakers do a good job to encourage more women participation in technology with meetups, conferences and hackathons. One of those conferences, Tech(k)now Day, happened in London on Ada Lovelace Day and I was happy that Google Cloud was a sponsor. We had a booth and I was there with other Googlers answering questions. I also gave a talk on Containers and Kubernetes to a small group of 30+ people.

Deploying ASP.NET Core apps on Kubernetes/Container Engine

atamel@gmail.com (Mete Atamel) — Mon, 11 Sep 2017 10:27:00 +0000

In my previous post, I talked about how to deploy a containerised ASP.NET Core app to App Engine (flex) on Google Cloud. App Engine (flex) is an easy way to run containers in production: Just send your container and let Google Cloud figure out how to run it at scale. It comes with some nice default features such as versioning, traffic splitting, dashboards and autoscaling. However, it doesn’t give you much control.

Deploying ASP.NET Core apps on App Engine

atamel@gmail.com (Mete Atamel) — Tue, 15 Aug 2017 04:32:34 +0000

I love how easy it is to deploy and run containerized ASP.NET Core apps on App Engine (flex). So much so that, I created a Cloud Minute recently to show you how, here it is.

It basically involves 3 steps:

Create your ASP.NET Core app using dotnet command line tool inside Cloud Shell and publish your app to get a self-contained DLL.
Containerize your app by creating a Dockerfile, relying on the official App Engine image and pointing to the self-contained DLL of your app.
Create an app.yaml file for App Engine and use gcloud to deploy to App Engine.

That’s it! If you want to go through these steps yourself, we also have a codelab for you that you can access here.

Putting gRPC multi-language support to the test

atamel@gmail.com (Mete Atamel) — Mon, 08 May 2017 00:00:00 +0000

gRPC is an RPC framework developed and open-sourced by Google. There are many benefits to gRPC, such as efficient connectivity with HTTP/2, efficient data serialization with Protobuf, bi-directional streaming and more, but one of the biggest benefits is often overlooked: multi-language support.

Out of the box, gRPC supports multiple programming languages : C#, Java, Go, Node.js, Python, PHP, Ruby and more. In the new microservices world, the multi-language support provides the flexibility you need to implement services in whatever language and framework you like and let gRPC handle the low-level connectivity and data transfer between microservices in an efficient and consistent way.

Windows and .NET on Google Cloud Platform

atamel@gmail.com (Mete Atamel) — Mon, 20 Mar 2017 09:25:05 +0000

Originally published in SDN Magazine 131 in February 2017.

Introduction

Until recently, there were two distinct camps in the software world: the Windows (A.K.A. closed) world and the Linux (A.K.A. open) world. In the Linux world, we had tools like the bash shell, Java programming language, Eclipse IDE, MySQL database, and many other open-source projects by Apache. In the Windows world, we had similar, yet distinct tools mainly developed by Microsoft, such as the C# programming language, Visual Studio IDE, SQL Server and PowerShell.

Windows and .NET Codelabs - an overview

atamel@gmail.com (Mete Atamel) — Tue, 07 Feb 2017 00:00:00 +0000

Google Developers Codelabs provide guided coding exercises to get hands-on experience with a wide range of topics such as Android Wear, Firebase and Web. Google Cloud Platform (GCP) has its own section, with codelabs for Google Compute Engine, Google App Engine, Kubernetes and many more.

We’re always working to create new content, and I’m happy to announce that we now have new codelabs for running Windows and .NET apps on GCP, with their own dedicated page. Here’s an overview to help you get started.

From the Monolith to Microservices

atamel@gmail.com (Mete Atamel) — Mon, 23 Jan 2017 11:26:15 +0000

I remember the old days where we used to package all our modules into a single app (aka the Monolith), deployed everything all at once and called it an enterprise app. I have to admit, the first time I heard the term enterprise app, it felt special. Suddenly, my little module was not so little anymore. It was part of something bigger and more important, at least that’s what I thought. There was a lot of convention and overhead that came with working in this enterprise app model but it was a small price to pay for consistency, right?

Google Cloud Next’17

atamel@gmail.com (Mete Atamel) — Thu, 19 Jan 2017 00:00:00 +0000

In my previous post, I promised to talk about some good conferences I’m attending or speaking over the coming months. One of those conferences that I’m most excited about is Google Cloud Next’17: Google’s main cloud conference happening March 8–10 in San Francisco.

Last year, I attended that conference as a Noogler. There were a lot of developers and great technical content. This year’s schedule has just been published and it looks even more exciting, especially if you’re a .NET developer!

How to build and launch an ASP.NET Core app from Google Cloud Shell — without ever leaving the browser

atamel@gmail.com (Mete Atamel) — Fri, 11 Nov 2016 00:00:00 +0000

Google Cloud Shell, my favorite development tool for Google Cloud Platform, just got more awesome with two new features.

First, we recently integrated Eclipse Orion, an online code editor, with Cloud Shell. If you’re not a Vim or Emacs fan, Orion is a welcome addition to Cloud Shell. It enables you to edit code right inside the browser with basic syntax highlighting and minimal effort.

Second, we added .NET Core command line interface tools to Cloud Shell. This is a new cross-platform toolchain for developing .NET Core applications and it can be used to create, run and publish .NET Core apps from the command line.

Managing containerized ASP.NET Core apps with Kubernetes

atamel@gmail.com (Mete Atamel) — Fri, 14 Oct 2016 00:00:00 +0000

One of our goals here on the Google Cloud Platform team is to support the broadest possible array of platforms and operating systems. That’s why we’re so excited about the ASP.NET Core, the next generation of the open source ASP.NET web framework built on .NET Core. With it, .NET developers can run their apps cross-platform on Windows, Mac and Linux.

One thing that ASP.NET Core does is allow .NET applications to run in Docker containers. All of a sudden, we’ve gone from Windows-only web apps to lean cross-platform web apps running in containers. This has been great to see!

Running Powershell on Google Cloud SDK

atamel@gmail.com (Mete Atamel) — Tue, 13 Sep 2016 00:00:00 +0000

It’s exciting to see so many options for .NET developers to manage their cloud resources on Google Cloud Platform. Apart from the usual Google Cloud Console, there’s Cloud Tools for Visual Studio, and the subject of this post: Cloud Tools for PowerShell.

PowerShell is a command-line shell and associated scripting language built on the .NET Framework. It’s the default task automation and configuration management tool used in the Windows world. A PowerShell cmdlet is a lightweight command invoked within PowerShell.

Getting started with Cloud Tools for Visual Studio

atamel@gmail.com (Mete Atamel) — Thu, 08 Sep 2016 00:00:00 +0000

If you’re a .NET developer, you’re used to managing cloud resources right inside Visual Studio. With the recent release of our Cloud Tools for Visual Studio, you can also manage your Google Cloud Platform resources from Visual Studio.

Cloud Tools is a Visual Studio extension. It has a quickstart page with detailed information on how to install the extension, how to add your credentials and how to browse and manage your cloud resources. In this post, I want to highlight some of the main features and refer to individual how-to pages for details.

Getting started with Google Cloud Client Libraries for .NET

atamel@gmail.com (Mete Atamel) — Fri, 26 Aug 2016 00:00:00 +0000

Last week, we introduced new tools and client libraries for .NET developers to integrate with Google Cloud Platform, including Google Cloud Client Libraries for .NET, a set of new client libraries that provide an idiomatic way for .NET developers to interact with GCP services. In this post, we’ll explain what it takes to install the new client libraries for .NET in your project.

Scheduling Dataflow pipelines using App Engine Cron Service or Cloud Functions

atamel@gmail.com (Mete Atamel) — Tue, 12 Apr 2016 00:00:00 +0000

Google Cloud Dataflow provides a unified programming model for batch and stream data processing along with a managed service to execute parallel data processing pipelines on Google Cloud Platform.

Once a Dataflow pipeline is created, it can be tested locally using DirectPipelineRunner, and if everything looks good, it can be manually executed as a job in Dataflow Service by triggering DataflowPipelineRunner or BlockingDataflowPipelineRunner with Apache Maven or Dataflow Eclipse Plugin. You can monitor the progress of your submitted job with Dataflow Monitoring Interface from Cloud Platform Console or Dataflow Command-line Interface from gcloud.

My knee journey

atamel@gmail.com (Mete Atamel) — Mon, 01 Jan 0001 00:00:00 +0000

Why this page?
First and second injuries and first surgery in 2009
Third injury in March 2023
Second surgery on April 25, 2023
Week 1
Week 2
Week 3
Week 4
Week 5
Week 6
Week 7
Week 8
Month 3
Month 4
Month 7
Month 9
Month 12
Month 20

Why this page?

In March 2023, I had a knee injury that required a knee surgery on April 25, 2023. I created this page to document my surgery and recovery progress in detail for myself. I also found it incredibly useful to read about other people’s experiences with knee surgery and recovery, so I hope this also helps someone else out there today or in the future.

Speaker Profile

atamel@gmail.com (Mete Atamel) — Mon, 01 Jan 0001 00:00:00 +0000

About

I’m a Software Engineer and a Developer Advocate at Google in London. I build tools, demos, tutorials, and give talks to educate and help developers to be successful on Google Cloud.

Asking me to speak at your conference

If you want to invite me to speak at your tech conference, please send me a message on LinkedIn or Twitter with details of the event:

What’s the name, date, and history of the event?
Is it an online, hybrid, or in-person event?
What’s the attendee profile (software engineers, architects, C-level, etc.)?
What’s the expected attendee number (overall and per session)?

Speaking history

Here’s some info on my talks and workshops:

Talks List

atamel@gmail.com (Mete Atamel) — Mon, 01 Jan 0001 00:00:00 +0000

I did 423 talks/workshops since 2016.

2026

I had 8 talks/workshops.

Event	Date	Topic
Cloud & AI Train the Trainer - Istanbul	2026-03-13	Gemini for developers workshop
Cloud & AI Train the Trainer - Istanbul	2026-03-13	AI workshop masterclass
Builders Day Istanbul - Online	2026-03-12	Gemini for developers
Startup Sprint Day - Online	2026-03-05	Gemini for developers
Cloud & AI Train the Trainer - London	2026-03-04	AI workshop masterclass
Cloud & AI Train the Trainer - Berlin	2026-02-25	AI workshop masterclass
AgentCon - Istanbul	2026-02-07	Agent Protocols: MCP, A2A, and ADK in Action
Cloud Labs - Limassol	2026-01-28	Gemini for developers & Google Antigravity

2025

I had 29 talks/workshops.