Professional Cloud Developer
Professional Cloud Developer
Intermediate
Gauge your current knowledge
Intermediate
Gauge your current knowledge
Creating and deploying APIs (e.g., HTTP REST, gRPC [Remote Procedure Call])
...
Professional Cloud Developer
Gauge your current knowledge
Gauge your current knowledge
Choosing the right protocol is critical for building reliable, scalable cloud-native applications. HTTP REST is a common style using standard web methods, while gRPC is a high-performance framework. The two protocols define service contracts differently. REST APIs rely on OpenAPI to describe endpoints and data in human-readable formats, while gRPC uses Protocol Buffers for structured, language-neutral data serialization. This schema enforcement in gRPC enables stricter service contracts and automated code generation across multiple languages.
Performance depends heavily on data serialization formats. REST uses JSON, which is easy to read but is slow and bulky to transmit. In contrast, gRPC uses a compact binary format that is much faster to serialize and deserialize. This binary format makes gRPC the ideal choice for high-performance internal microservices where speed and low latency are critical.
Communication patterns offer different options for how data flows between services. While REST is typically limited to unary (one-to-one) request-response interactions, gRPC supports more advanced streaming models:
These patterns provide the flexibility needed for real-time applications and complex data flows.
To secure API communication, developers use JWT (JSON Web Tokens) to manage authentication and authorization across distributed environments. Deployments are kept safe by validating code and packages before they go live. The Artifact Analysis API works with security metadata to ensure that all deployed code is secure and verified. Implementing these security steps prevents unauthorized access to sensitive API endpoints.
Both REST and gRPC serve as the foundational protocols for cloud-native APIs, with REST handling simple JSON messaging and gRPC enabling high-speed service-to-service connections. Security at the transport layer begins with TLS encryption, which keeps sensitive data safe as it moves across the network. Access is managed through Identity and Access Management (IAM), which provides fine-grained authorization. To prevent system-wide lockouts, multiple trusted administrators must have access to API keys and other core secrets.
Operational reliability relies on redundancy and globally distributed architectures. Using Global APIs and global resources ensures fault tolerance because services are spread across multiple zones. If one zone fails, the system stays online without interruption. Developers deploy Managed Instance Groups combined with Cloud Load Balancing to automatically distribute traffic, recover from errors, and maintain high availability.
Observability helps teams measure the health of their APIs using Service Level Indicators (SLIs) and Service Level Objectives (LOs). These metrics track performance goals and alert teams to technical issues. To stay on top of system performance, operations teams use specific monitoring features:
Finally, enforcing Quotas and Rate Limiting prevents any single user or service from overwhelming the application with traffic, protecting the cloud environment from resource exhaustion.
API management services act as a facade, hiding the complexity of backend services from client applications. This proxy layer lets developers change backend code or update server locations without breaking frontend integrations. Google Cloud provides three primary tools for managing these interfaces, each suited for different architectures. Apigee delivers enterprise-grade management that supports hybrid and multicloud deployments. Meanwhile, API Gateway is a fully managed service for securing serverless backends like Cloud Run, and Cloud Endpoints helps manage APIs running on Compute Engine or Google Kubernetes Engine (GKE).
When integrating systems that use different protocols, developers can bridge REST and gRPC environments. To support this, ESPv2 performs transcoding, which automatically translates incoming HTTP/JSON requests into gRPC. This allows legacy or web clients to communicate seamlessly with high-performance gRPC backends. Deployment of these APIs uses a service proxy, such as the Extensible Service Proxy (ESP), which runs inside containers alongside the backend code on Cloud Run, GKE, or Compute Engine.
The service proxy handles key tasks including authentication, logging, and quota management at the edge of the service. To optimize speed and protect these services, APIs should be paired with Cloud Load Balancing and Cloud CDN. These network services reduce latency and improve availability by caching data near users and distributing traffic across regions. For advanced protection, Google Cloud Armor acts as a web application firewall to defend the APIs against external digital attacks.