Google Cloud Platform for developers build highly scalable cloud solutions with the power of Google Cloud Platform
Develop, deploy, and scale your applications with Google Cloud Platform Key Features Create and deploy your applications on Google Cloud Platform Store and manage source code and debug Cloud-hosted apps with plugins and IDEs Streamline developer workflows with tools for alerting and managing deploym...
| Otros Autores: | , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham :
Packt
2018.
|
| Edición: | 1st edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009630490306719 |
Tabla de Contenidos:
- Cover
- Title Page
- Copyright and Credits
- Packt Upsell
- Contributors
- Table of Contents
- Preface
- Chapter 1: Why GCP?
- The public cloud landscape
- Amazon Web Services
- Microsoft Azure
- Google Cloud Platform
- Standing on the shoulders of giants
- A world-class global presence
- Choosing your own adventure
- Leading the way for big data
- The Open Cloud and innovation
- Dedication to customer success
- Bottom-up security
- In good company
- Summary
- Chapter 2: The Google Cloud Console
- Getting started - Google Cloud projects
- Architectural role of Google Cloud projects
- Creating a project
- Free trials on GCP
- The Google Cloud Console
- Understanding the Cloud Console dashboard
- The Google Cloud Shell
- Launching the Cloud Shell
- Supporting multiple sessions
- Features and integrations
- File management
- Web Preview
- The Cloud Shell Code Editor
- Opening in Cloud Shell
- Trying it out
- Installing additional tools
- Boost mode
- Repairing the Cloud Shell
- Other tools
- Mobile apps
- Developer tool integrations
- Summary
- Chapter 3: APIs, CLIs, IAM, and Billing
- Google Cloud APIs
- Managing APIs
- Google APIs Explorer
- Trying out the APIs Explorer
- The Google Cloud SDK
- Installing the Google Cloud SDK
- The gcloud command-line tool
- The basics of gcloud
- Command groups
- Root commands
- Global flags
- Initializing the Google Cloud SDK
- Authentication
- Managing your Google Cloud SDK
- Updating and rollbacks
- Alpha and beta channels
- Configurations in the Google Cloud SDK
- Modifying configuration properties
- Multiple configurations
- Other command-line tools
- bq
- gsutil
- kubectl
- Automating tasks with gcloud
- Modifying output and behavior
- Formatting attributes
- Formatting projections
- Filtering
- Google Cloud IAM
- How IAM works.
- IAM roles
- The structure of IAM policies
- Organization-level policies
- Project-level policies
- Resource-level policies
- Cross-project access
- Managing IAM
- Service accounts
- Billing on Google Cloud
- Billing accounts
- Billing accounts and IAM
- Budgets and billing alerts
- Google Cloud Platform Pricing Calculator
- Creating an estimate
- Summary
- Chapter 4: Google App Engine
- Compute services on the GCP
- Google Compute Engine
- Google Kubernetes Engine (GKE)
- Google App Engine
- Google Cloud Functions
- General considerations
- Google App Engine
- Features and benefits
- Developer velocity
- Visibility
- Scalability
- Simple integrations
- Structure of a Google App Engine application
- Architecture of an App Engine solution
- Microservices
- Batch work and task queues
- App Engine locations
- IAM on the Google App Engine
- App Engine service accounts
- The standard and flexible environments
- Standard environment
- Flexible environment
- Setting up the App Engine
- The App Engine standard environment
- Language support
- Developing for the App Engine standard environment
- The Python runtime
- WSGI and CGI
- Getting started
- The App Engine development server
- The Go runtime
- Running multiple services locally
- The Java 8 runtime
- Deploying App Engine standard services
- Deployment behavior
- Splitting network traffic
- Instance classes
- Pricing in the standard environment
- Spending limits
- The App Engine flexible environment
- Benefits of the flexible environment
- More control over the infrastructure
- Application portability
- Language support
- Developing for the flexible environment
- Deploying App Engine flexible apps
- Container technologies
- Google Container Builder
- Google Container Registry
- Custom runtimes
- Building custom runtime services.
- Deploying a service to the flexible environment
- Pricing in the flexible environment
- App Engine resources and integrations
- Task queues
- Push and pull queues
- Push queues
- Named queues
- Pull queues
- Creating tasks
- Structuring tasks queues
- Scheduled tasks
- Deploying a cron definition
- Trying the App Engine cron service
- Scaling App Engine services
- Autoscaling
- Basic and manual scaling
- Externalizing configuration and managing secrets
- Application configuration files
- Compute Engine metadata server
- Runtime Configurator
- Cloud Key Management Service (KMS)
- General considerations
- Networking and security
- The App Engine firewall
- Cloud Endpoints
- Google Cloud IAP
- Virtual private networks
- Summary
- Chapter 5: Google Kubernetes Engine
- Google Kubernetes Engine
- When to choose GKE
- GKE or App Engine Flex
- Creating and maintaining a GKE cluster
- Node pools
- Multi-zonal and regional clusters
- Container Registry
- Deploying workloads to GKE
- Rolling updates
- Rolling back updates
- Scaling deployments
- Manually scaling deployments
- Automatically scaling deployments
- Exposing GKE Services
- Exposing services within a cluster
- Exposing services to external traffic
- Managing secrets with GKE
- Creating/Storing secrets
- Using secrets
- Billing
- Summary
- Chapter 6: Google Cloud Functions
- Functions as a Service
- Google Cloud Functions
- Advantages of Cloud Functions
- Price
- Scalability
- Developer velocity
- Considerations when using Cloud Functions
- Invoking Cloud Functions
- HTTP functions
- Processing HTTP requests
- Background functions
- Cloud Pub/Sub functions
- Cloud Storage functions
- Background function retries and termination
- Developing Cloud Functions
- Using the Cloud Console
- Local development
- Debugging functions.
- Deploying Cloud Functions
- Deploying from a local machine
- Deploying from a source repository
- Integrating with other Google services
- IAM and billing
- Cloud Functions and IAM
- Frameworks and tooling
- Summary
- Chapter 7: Google Compute Engine
- Understanding Compute Engine
- IaaS
- Infrastructure as Code (IaC)
- More than virtual machines
- When to use Compute Engine
- A straightforward migration path
- Host anything
- Building a robust global presence
- Long running and resource intensive processes
- Security and compliance
- Virtual machines on Google Compute Engine (GCE)
- Machine types
- Standard machine types
- High-memory machine types
- Mega-memory machine types
- High-CPU machine types
- Shared-core machine types
- Custom machine types
- Extended memory
- Other resources
- Disk storage
- GPUs
- Images
- Public images
- Premium images
- Community images
- Container images
- Managing Compute Engine instances
- Creating instances
- Remote access
- SSH access
- SCP access
- Remote Desktop Protocol (RDP) access
- Metadata server
- Default metadata
- Project-wide metadata
- Instance-specific metadata
- Setting and removing metadata
- Querying metadata from within instances
- Trying it out
- Modifying API responses
- Startup and shutdown scripts
- Startup scripts
- Shutdown Scripts
- Windows machines
- Updates and patches
- Availability policies
- Maintenance behavior
- Restart behavior
- Relocating an instance
- Storage solutions
- Persistent disks
- Standard and solid-state drive (SSD) persistent disks
- Persistent disk performance
- Boot disks
- Managing persistent disks
- Persistent disk snapshots
- Local SSDs
- Creating scalable solutions with GCE
- Custom images
- Creating images from a persistent disk
- Copying an image
- Creating images from snapshots.
- Golden images
- Security concerns
- Managed instance group (MIG)
- Instance templates
- Creating MIGs
- Built for resilience
- Autoscaling
- Autohealing
- Change management
- Performing a rolling update
- IAM and service accounts
- Administrative operations
- General roles
- Compute resource roles
- Network and security resource roles
- Compute instance IAM
- Pricing on GCE
- Instance discounts
- Preemptible instances
- Committed use discounts
- Sustained use discounts
- Other resource costs
- Always-free tier
- Summary
- Chapter 8: NoSQL with Datastore and Bigtable
- NoSQL solutions on GCP
- NoSQL technologies
- Google Cloud Datastore
- When to use Datastore
- Getting started
- Datastore locations
- Managing entities in the Cloud Console
- Datastore core concepts
- The structure of Datastore data
- Entities, kinds, and properties
- Data types
- Entity identifiers
- Namespaces
- Ancestry paths and keys
- Entity groups and consistency
- Entity groups
- Consistency and queries
- Working with entities
- Queries with GQL
- Using GQL in the Cloud Console
- Indexes
- Single property indexes
- Composite indexes
- Datastore under the hood
- The entities table
- Key
- Entity group
- Kind
- Properties
- Custom indexes
- Index tables
- EntitiesByKind
- EntitiesByProperty
- EntitesByCompositeProperty and Custom Indexes
- Datastore management and integrations
- Administrative tasks
- The Datastore Admin Console
- gcloud operations
- Integrations with other GCP services
- App Engine standard environment
- Other GCP services
- Datastore pricing and IAM
- Permissions in Datastore
- Google Cloud Firestore
- Comparison to Datastore
- A promising future
- Google Bigtable
- Core concepts
- Structure of Bigtable data
- Columns and column families
- Column families
- Scalable and intelligent.
- Bigtable under the hood.
