The Cloud trust paradox: To trust cloud computing more, you need the ability to trust it less

At their core, many cloud security and, in fact, cloud computing discussions ultimately distill to trust. This concept of trust is much bigger than cyber security, and even bigger than a triad of security, privacy, and compliance.For example, trust may involve geopolitical matters focused on data residency and data sovereignty. At the same time, trust may even be about the emotional matters, something far removed from the digital domain of bits and bytes, going all the way to the entire society.In a decade since the rise of cloud computing, a lot of research has been generated on the topic of cloud trust. Today, the very concept of “using public cloud” is inseparably connected to “trusting your cloud provider.” One of the clear themes that emerged was that to be able to trust cloud computing, you need to be able to trust it less.A paradox? Not really! Imagine you have two choices:Trust a cloud provider that has a lot of well-designed data security controls.Trust a cloud provider that has a lot of well-designed data security controls and an ability to let you the customer hold the encryption key for all your data (without any ability of the provider to see the key).For sure, security, privacy and compliance controls contribute to trust in cloud computing in general and your cloud provider in particular. However, it is still easier to trust if you can trust less. Moreover, there is additional magic in this: I bet that simply knowing that your cloud provider is working in the direction of reducing the amount of trust you need to place in them will probably make you trust them more. This is true even if you don’t use all the trust-requirement-reducing features, such as Google Cloud External Key Manager that allows a customer to keep their key encryption keys on premises and to never have them come to Google Cloud, or Confidential VMs that encrypts the sensitive data during processing [a good read on this topic). Note that this logic applies even for cases where a public cloud environment is measurably more secure than an old on-premise environment—yet on-premises somehow feels more secure and hence more trusted.This means that building technologies that allow organizations to benefit from cloud computing, while decreasing the amount of trust they need to place into the provider controls (both technical and operational) is of huge importance. However, such technologies are not only about the notional trust benefits—let’s speak about specific threat models. To list a few, the threats that are addressed by this particular example of trust-requirement-reducing technology—our EKM. These are (in our opinion):Accidental loss of encryption keys by the provider (however this is unlikely) is mitigated by EKM; because the provider does not have the keys, it cannot lose them whether due to a bug, operational issue or any other reason.Along the same line, a misconfiguration of native cloud security controls can, in theory, lead to key disclosure. Keeping the key off the cloud and in the hands of a cloud customer will reliably prevent this (at the cost of a risk of key being lost by a client).A rogue provider employee scenario is also mitigated as said rogue employee cannot ever get access to the encryption key (this is also mitigated by a cloud HSM route)— admittedly, this is even more unlikely.Finally, if some entity requests that a provider surrender the keys to a particular client’s data, this becomes impossible because said keys are not in provider’s possession (here, we will leave this as an exercise to the reader to decide how unlikely that may be).Operationally, protections such as EKM make sense for a subset of sensitive data. For example, an organization may process sensitive data in the cloud, and only apply such trust reduction  (or, better: “trust externalization”) for some of the data that is truly the most sensitive.As we established, such trust-requirement-reducing technologies are not only about security threats. Their contribution to compliance is also significant: they can help meet any requirement for a cloud customer to maintain the possession of encryption keys and also to any mandate to separate keys from data.In fact, trust in the cloud is further enhanced by letting the customer have direct control over key access. Specifically, by retaining control of the keys, a cloud customer gains an ability to cut off cloud data processing by preventing key access. Again, this is important for both actual threats and security/trust signalling.Furthermore, here is an interesting edge case: you may trust your cloud provider, but not the country where they are located or under whose laws they operate. This is where trust again moves outside of the digital domain into a broader world. Our trust-requirement-reducing approach works here as well; after all, if nobody outside of a customer has the keys, nobody can compel any 3rd party (including a cloud provider) to reveal the keys and, hence, the sensitive data.Now, a trick question: won’t there be a challenge of needing to trust the provider to build the “trust reducing controls” correctly? Yes. However, we think there is a big difference between “just trust us” and “here is the specific technology we build to reduce trust; trust we built it correctly because of these reasons.” In other words, trust us because we let you trust us less.Finally, some thoughts to keep this going:Be aware that trust is much broader than security, compliance, and privacy.Keep in mind that it is easier to trust a cloud provider that enables you to trust them less.Specific threat models still matter—trust improvement alone probably won’t make people adopt new technologies.Watch this fun Google Cloud NEXT OnAir presentation on this topic.Finally, add “trust reduction” to your security arsenal: you can secure system components, sure, but you can also architect the system in such a way that you need to trust the components less. Win!
Quelle: Google Cloud Platform

3 Ways to optimize Cloud Run response times

Serverless containerization has taken the world by storm as it gives developers a way to deploy their stateless microservices without a heavy burden of infrastructure management. Cloud Run abstracts all infrastructure management. You hand over a container image with a web server and stateless logic, and specify a combination of memory/CPU and allowed concurrency. Cloud Run takes care of creating an HTTP endpoint, routing requests to containers, and scaling containers up and down to handle the volume of requests. While Cloud Run offers some native features to reduce response time latency, such as idle instances, much of it can be improved by writing effective services, which I’ll outline below. Idle instancesAs traffic fluctuates, Cloud Run attempts to reduce the chance of cold starts by keeping some idle instances around to handle spikes in traffic. For example, when a container instance has finished handling requests, it might remain idle for a period of time in case another request needs to be handled.But, Cloud Run will terminate unused containers after some time if no requests need to be handled. This means a cold start can still occur. Container instances are scaled as needed, and it will initialize the execution environment completely. While you can keep idle instances permanently available using the min-instance setting, this incurs cost even when the service is not actively serving requests. So, let’s say you want to minimize both cost, and response time latency during a possible cold start. You don’t want to set a minimum number of idle instances, but you also know any additional computation needed upon container startup before it can start listening to requests means longer load times and latency. Cloud Run container startup There are a few tricks you can do to optimize your service for container startup times. The goal here is to minimize the latency that delays a container instance from serving requests. But first, let’s review the Cloud Run container startup routine. At a high level, it consists of:Starting the serviceStarting the containerRunning the entrypoint command to start your serverChecking for the open service portYou want to tune your service in order to minimize the time needed for step 1a. Let’s walk through 3 ways to optimize your service for Cloud Run response times.#1 Create a leaner serviceFor starters, on Cloud Run, the size of your container image does not affect cold start or request processing time. Large container images, however, mean slower build times, and slower deployment times.You want to be extra careful when it comes to applications written in dynamic languages. For example, if you’re using Node.js or Python, module loading that happens on process startup will add latency during a cold start.Also be aware of some modules that run initialization code upon importing.To build a leaner service you can:Minimize the number and size of dependencies if you’re using a dynamic language.Instead of computing things upon startup, compute them lazily. The initialization of global variables always occurs during startup, which increases cold start time. Use lazy initialization for infrequently used objects to defer the time cost and decrease cold start times.Shorten your initializations and speed up time to start your HTTP server.And use code-loading optimizations like PHP’s composer autoloader optimization.#2 Use a smaller base imageYou want to build a minimal container by working off a lean base image like: alpine, distroless. For example, the alpine:3.7 image is 71 MB smaller than the centos:7 image. You can also use, scratch, which is an empty image on which you can build your own runtime environment. If your app is a statically linked binary, it’s easy to use the scratch base image:You should also only install what is strictly needed inside the image. In other words, don’t install extra packages that you don’t need.#3 Use global variablesIn Cloud Run, you can’t assume that service state is preserved between requests. But, Cloud Run does reuse individual container instances to serve ongoing traffic. That means you can declare a global variable. When new containers are spun up, it can reuse its value. You can also cache objects in memory. Moving this from the request logic to global scope means better performance when traffic is ongoing. Now this doesn’t exactly help cold start times, but once the container is initialized, cached objects can help reduce latency during subsequent ongoing requests. For example, if you move per-request logic to global scope, it should make a cold starts last approximately the same amount of time (and if you add extra logic for caching that you wouldn’t have in a warm request, it would increase the cold start time), but any subsequent request served by that warm instance will have a lower latency.One option that can help with cold starts is to offload global state to an in-memory datastore like Memorystore, which provides sub-millisecond data access to application caches. ConclusionA lot of this boils down to creating a leaner service so logic that computes during container initialization is minimized, and it can start serving requests as soon as possible. While these are just a few best practices for designing a Cloud Run service, there are a number of other tips for writing effective services and optimizing performance, which you can read about here. For more cloud content follow me on Twitter @swongful.Related Article3 cool Cloud Run features that developers loveCloud Run developers enjoy pay-per-use pricing, multiple concurrency and secure event processing.Read Article
Quelle: Google Cloud Platform

Compose CLI ACI Integration Now Available

Today we are pleased to announce that we have reached a major milestone, reaching GA and our V1 of both the Compose CLI and the ACI integration.

In May we announced the partnership between Docker and Microsoft to make it easier to deploy containerized applications from the Desktop to the cloud with Azure Container Instances (ACI). We are happy to let you know that all users of Docker Desktop now have the ACI experience available to them by default, allowing them to easily use existing Docker commands to deploy and manage containers running in ACI. 

As part of this I want to also call out a thank you to the MSFT team who have worked with us to make this all happen! That is a big thank you to Mike Morton, Karol Zadora-Przylecki, Brandon Waterloo, MacKenzie Olson, and Paul Yuknewicz.

Getting started with Docker and ACI 

As a new starter, to get going all you will need to do is upgrade your existing Docker Desktop to the latest stable version (2.5.0.0 or later), store your image on Docker Hub so you can deploy it (you can get started with Hub here) and then lastly you will need to create an ACI context to deploy it to. 

We have done a few blog posts now on the different types of things you can achieve with the ACI integration. 

Getting started locally using Docker & ACI Paul’s blog over at MSFT on getting started with Docker & ACIDeploying a Minecraft server & using volumes with ACI Deploying to ACI as part of Github actions for CD Docker & ACI integration into VSCodeDockers docs on the integration 

If you have other questions on the experience or would like some other guides then drop us a message in the Compose CLI repo so we can update our docs. 

What’s new in V1.0 

Since the last release of the CLI we have added a few new commands to make it easier to manage your working environment and also make it simpler for you to understand what you can clear up to save you money on resources you are not using.

To start we have add a volume inspect command alongside the volume create to allow you better management of your volumes: 

We are also very excited by our new top level prune command to allow you to better clear up your ACI working environment and manage your costs. 

docker prune –help

We have also added in a couple of interesting flags in here, we have the —dry-run flag to let you see what would be cleared up:

(OK I am not running a great deal here!) 

As you can see, this also lets you know the amount of compute resources you will be reclamining as well. At the end of a development session being able to do a force prune allows you to remove ‘all the things you have run’, giving you the confidence you won’t have left something running and get an unexpected bill. 

Lastly we have started to add a few more flags in based on your feedback, a couple of examples of these are the addition of the –format json and –quiet in commands ps, context ls, compose ls, compose ps, volume ls to output json or single IDs.

We are really excited about the new experience we have built with ACI, if you have any feedback on the experience or have ideas for other backends for the Compose CLI please let us know via our Public Roadmap
The post Compose CLI ACI Integration Now Available appeared first on Docker Blog.
Quelle: https://blog.docker.com/feed/

AWS Client VPN kündigt Self-Service-Portal zum Herunterladen von VPN-Profilen und Desktop-Anwendungen an

Das Client VPN Self-Service-Portal ist ein schreibgeschütztes Webportal, das Endbenutzern von Client VPN hilft, das VPN-Profil und aktualisierte Versionen der AWS Client VPN Desktop-Anwendung herunterzuladen. Endbenutzer können das VPN-Profil und die Desktop-Anwendung direkt auf ihre Computer herunterladen. Wir werden auch weiterhin die Möglichkeit für Endbenutzer unterstützen, die Desktop-Anwendung direkt herunterzuladen, ohne dass sie irgendwelche Anmeldedaten eingeben müssen.  
Quelle: aws.amazon.com