The Complete Course from ExamCollection industry leading experts to help you prepare and provides the full 360 solution for self prep including Professional Cloud Developer Certification Video Training Course, Practice Test Questions and Answers, Study Guide & Exam Dumps.

App Engine – PaaS

1. App Engine Security Scanner

Let's go ahead and create an App Engine security scan. Now, as you may be aware, App Engine has a tool that's built in that is really a tool set, I should say, of tools that are going to scan your App Engine service that you have deployed on the App Engine platform. Essentially, we know that, of course, App Engine is going to provide an application stack. It's going to support whatever development language that you're using, and it's going to include these tools that are called security scanners. Now, what we want to do is,of course, consider a few things. The first thing is that it will go ahead and perform the scan via what's called a parsing approach. So it's going to go ahead and parse your website. That's going to be an HTML It will emulate a browser as well. Now it'll go ahead and look for CSSissues, for example, errors like that, known vulnerabilities. But it won't be super complex in the sense that it's going to look for JavaScript code vulnerabilities. For example. Some of the vulnerabilities that you ran, for example, might have missed them in the first scan, but you could run them again in what's called a "full scan" that might find them. So if you do a quick scan instead of a fast scan, it may or may not find certain vulnerabilities. So just be aware that scanners have controls and inputs. Generally, it's going to evaluate pretty much everything that has a known vulnerability. So there are a few things that could be missed. But anyway, with that set to deploy the scan, what we want to do is go to Security Scanner. Now, the first time you deploy security scanners, you may need to enable the API. So I've already run a scan, so I don't need to worry about that. But you may get a pop-up saying that the API needs to be enabled. Would you like to go ahead and proceed? I'm going to go ahead and create scans. Now, the first thing is that you can see that the scannumber is named, so I can name this whatever I want. It already picked up my website, which has already been deployed. And you can go ahead and validate this by going over to this Hello World application right here. So it will scan that HelloWorld app for any vulnerabilities. And then I could also exclude certain URLs. I could also select specific authentication requirements. I could schedule this whenever I want. I could run it daily. I could never schedule it if I didn't want to. I could also export this to what's called the Cloud Security Command Center, which is again a different tool, but it allows you to import the information from App Engine and export it over to the Command Center. Now, a couple of other things: we can also select the user agent. So if we want to test against Chrome or Safari on a mobile device such as a BlackBerry or Nokia iPhone, we could do that as well. Now there's a different system, basically QPS. These are the scans that will be performed per second. Essentially, we have three options: 510, 15, or 20, with 15 being the default. And then, once you're done, this is just a very basic scan. You go ahead and make something. Now what this is going to do is create the scan, but we still have to invoke it. So we go ahead and go run the scan, and what it's going to do is it'll go ahead and run the scan. And since this is just a WordPress template that was deployed, there isn't much here, and chances are it won't find anything. But we'll go back and check, and if there is a vulnerability, it will point that out. So we'll go back and check once it's done. So, this scan just finished; it took about ten minutes and seventeen seconds to scan a small WordPress site. didn't find any vulnerabilities as expected; it was just deployed. So no additional programmes loadedor scripts or anything. So just remember, it's very simple to run ASCAN, and you can also schedule it as well. Now, one of the things that it does scan, for example, is for a range of common vulnerabilities. It will look for Flash injection, CSS, scripting issues, and other content issues as well. It will also generally pick up, for example, outdated or insecure libraries as well.So it's a nice tool. I encourage developers to use this before they deploy anything. It usually picks up those issues pretty easily. Let's go ahead and move on. Bye.

2. App Engine Demo

Welcome back. Let's go ahead and do a quick little show-and-tell demo on App Engine again for the test. You don't need to know too much, but it is important to understand a few things about App Engine. Number one, it is a platform as a service. Number two, it comes in two different environments. So, do know that App Engine is standard and flexible. Remember that App Engine standards are typically good enough. But if you need more flexibility, like custom runtime environments, or you need some kind of ability to have attached discs like a thermal disc, then you need to go flexible. And then another good reason to go with App Engine is just the fact that you have so much flexibility in your development processes. It's got a robust SDK, and of course we talked about some of that already in the preceding slide deck. So all I wanted to do here was make sure that you could easily get to App Engine by going over to compute App Engine and Dashboard. I was saying I should have just clicked. So anyway, you can see that now before you set anything up. If you don't have AppEngine running, you're not going to see anything here. You'll have a little box here saying to go ahead and start with App Engine. You'll have to set up and download the APIs that you need as well as go through the process. Now, my recommendation is again: if you need help with anything, just follow the documentation or the wizards that are available as well. So you could go over here and select Instant Summary. So, basically, I deployed an instance, but it isn't running any applications. And so again, this is just for show-and-tell purposes. So there's nothing really going on really.But I come over here for services. You can see that this is the last version deployed. And then let's say I want to diagnose what's going on. Let's say, for example, I'm developing an app. I don't know why it's conking out. Go ahead and go over to Logs or Debug. It can help facilitate some of these versions. This will basically tell you what version of the instance you're running is. It'll let you know the traffic allocation that it's making. It tells you if you're running, what the runtime environment is, when it's deployed, et cetera. View the configuration here so you can see it deployed. At this time, you could tell this was running beta, et cetera. Then I move on to instances. Now again, you can see that there's nothing really running. There is only one instance visible, and there aren't many queues. Anything else going on would show me. Now. the Blob store. Now you can see that I didn't set anything up there. But again, if you want to create a "Blob" story, you can do that. But basically, it says you really should be using Google Cloud Storage. And again, that's the recommended process: just use Google Cloud Storage. It's just more flexible, et cetera. But if you click there, you'll see that it explains the various environments. It tells you about quotas and limits and everything like that. So again, there's not too much else to talk about. Now Memcache basically gives you the ability to run some of these processes in memory. If you want, you could share the cache or you could dedicate cash as well. best effort there is, class. You can see that it's shared or dedicated. So you can dedicate part of that, and then you can dedicate a specific size as well. But remember that your billing will be affected. So again, only do that unless it is really necessary. You could also flush cash over here as well. If you had a fair number of instances running, you would go here. You need to find a specific one; go ahead and search for it. Then you go over to settings, so you can see that these are the default settings. This is actually pretty cool. You could go ahead over here and set a custom domain. So, for example, you could set up a custom domain to route it to your pass. So again, you could do that. You could also register a new domain as well. So if you're developing, let's say, an online game app or something, and you want to have a custom name like, I don't know, Smurfsattackbaltimore.com, and you go ahead and register that domain, you can literally send all the traffic to your App Engine instance. So that's pretty interesting. And then as well, you get to upload certificates as you choose. So again, now remember, for App Engine, I'm going to reiterate three things, okay? Remember, App Engine is a platform as a service. Remember that App Engine has two environments, right? Remember, it's standard and flexible. Finally, keep in mind that the app engine supports Python, Java, and PHP. NodeJS is now only available in a flexible environment. And then there is another difference to that. Let me go back to the chart here. I don't know if I covered that very well. So I'm just going to go back here, right here. So one of the things that it doesn't really show is that with flexible virtual machines, you can actually expose your virtual machines to the outside world; with standard virtual machines, that doesn't happen. So, once again, recognise that flexibility requires a little more effort. It's not as managed in that sense. You need to be aware, for example, of the number of processes you're running. You may have to do some SSH, debugging, et cetera. But again, App Engine is a pretty cool tool for the right developers. And another thing I didn't mention—it's all beyond the scope of what we're recovering here—but microservices—you can absolutely run microservices with App Engine. Now, the services are essentially a way for you to take different parts of applications and be able to have little microservices as part of that application doing different things. So, for example, if you need to isolate services or split traffic, that's a great way to use microservices. So again, that capability is also defined in the capabilities of App Engine and whatever languages you're using for development. You could also auto-scale, you could also write those services to load and balance, and you could also have real-time, specific identity management. So that's about all that I had with the demo part. Play around with the App Engine. Again, you're looking at a question or two. No more direct testing around App Engine.

3. App Engine or Kubernetes Engine

Let's take a look at why you might want to use App Engine or a Kubernetes engine to deploy your application. And that is a great question, and one I am frequently asked. So I wanted to address that because it is an extremely interesting question in the sense that a lot of the basic features and functions are the same in some respects. So for example, when we consider using Kubernetesengineer Kubernetes engine, we could also deploy containersas well and App engine Flex as well. Now, App Engine Standard would be out if we wanted to use containers. So that's sort of the starting point: it's easy to rule out App Engine standards, but how do we rule out App Engine flexible environments versus Kubernetes engines? And it really comes down to a couple of factors. So with this said, App Engine Flexible is actually focused on application development. So, for example, if you have an application you want to deploy and have managed by Google on Google Cloud, then great. On the other hand, Days and the Kubernetes engine remember that you could deploy Kubernetes on-premises as well. So if you're using on-premises Kubernetes, then it would make sense to keep doing that or maybe extend it out to Google Cloud, depending on what you're trying to do. But Kubernetes is actually more flexible in what you can do. Another advantage of Cooper and Theis is the portability and independence of your cloud platform, which allows you to move those containers wherever you want. Now, with App Engine Flexible, once you deploy an App Engine Flexible, you're pretty much there because it's being managed by App Engine Flex. Also, App Engine Flexible has some limitations as well, in terms of how many applications you can deploy. Also, for example, one of the things ishow do you migrate out of App engine? Again, there are some things to think about there. There's also a performance challenge with the way it scales. But, if you do use App Engine, one of the benefits is that it is actually automated for you in the sense that Google handles everything in the background as a managed service. With Kubernetes's engine, generally, you need to spend more time managing it, which therefore requires essentially more administration. But with that said, it is a container service either way. It's just a question of what you need. Now, with Flex as well, basically you're deploying, for example, with App Engine, a number of containers of one type with Kubernetes Engine. Another thing is that they deploy more of a pod approach, for example. So again, there is a lot more to consider. It's not like a 1-hour discussion at a deep level, but there are some other things to think about, and I'll just list a few for you to think about and consider. One of the first things to consider is to understand how the containers are used with the Kubernetes engine. It's more about the containers. With App Engine, the containers are more or less in the background for the developers, so they're not managing containers. With Kubernetes Engine, it's all about the containers and keeping track of and managing them. So basically the user of App Enginedoesn't really per se get concerned aboutwhat's really going on in the background. Essentially, App Engine was created to be a tool for managing all of these services and removing the burden from developers. When it comes to flexing the flex environment in general, App Engine can definitely provide better throughput in the right use case because, once again, it's directly on Google's infrastructure and it's all managed by Google. Now, one of the things to also think about is that App Engine is going to scale automatically, and because of that, again, it's hands-off, whereas GKE can of course scale, but there's a little bit more work to have it do what you need. So for example, scaling up the number of nodes may take a little bit more work to get it exactly the way you want it. So for example, how do you address a workload that spikes versus a gradual increase? Now, one of the things to point out as far as similarities is that App Engine and GKE do share the same resources. So for example, you'd utilise the load balancer-managed infrastructure groups as well as instance groups, but again, from a compute engine perspective, it's still going to use those resources as well. Now, some of the templates may be a little different as well. For example, how do you scale, for example, by adjusting your vCPU, your RAM resources, etc.? The last two things to talk about before we move on are pricing and availability. Now, it is pretty clear that if you want to manage GKE yourself, the resources that you're using will be somewhat cheaper in a lot of cases than if you use App Engine. So you have to look at, for example, the virtual machines that you're using. So, for example, if you wanted to use PreemptibleVMs, you would undoubtedly save money with JK. That will not be the case with App Engine because it will not be using preemptible VMs in general. So if you want to deploy containers for a short test, for those not familiar with preemptible VMs, generally it's going to be a VM that's going to be similar to a Spot instance with AWS. That's a loosely comparable comparison, to be honest. But basically, you're going to get a price at about an 80% discount as compared to a standard VM. So, depending on what you're doing, you could potentially save a lot more money with GKE. All right, so there will definitely be a lot more to talk about with App Engine and Cuba Engine. But from a development perspective, I want to give you some ideas to think about and start looking into as far as what is right for your environment. Let's go ahead and wrap up the module here. So we want to just make sure that we understand from a review perspective that App Engine Flex is certainly more automated than GKE. And if you want to use GKE, youhave been flexibility and perhaps cost savings, butyou'll be doing more work as well. Right, let's go ahead and move on.

Kubernetes Engine

1. Kubernetes Engine

Let's talk about Kubernetes Engine and why we want to use it. We now know that when we deploy a container, it will almost always be a Docker container, which is the most common format out there. And if we do want to deploy, we could certainly deploy those containers, of course, on the Kubernetes Engine. But the main reason to use a container is to virtualize at the OS layer. It really separates the OS environment from your application, as well as any dependencies as well.But with that said, we're not going to really talk about Container 101 in this course. It's more of a refresher for those who are unfamiliar with Google Cloud and how containers fit into Kubernetes Engine. Now, the Kubernetes Engine is a managed environment. It is meant to deploy your containerized applications. It does deploy Docker containers, and the reason we want to deploy containers is for portability. But with that said, our workloads can be adjusted. We're going to deploy clusters. Again, there are numerous compelling reasons to deploy containers on Kubernetes Engine. Those who have been around for a while will be aware that Kubernetes Engine was previously known as Container Engine. One of the purposes of GKE is to enable you to manage applications and not machines. Now, this is really important to understand the value of using a container management system such as Kubernetes Engine. For example, as a developer, you may not want to be concerned about load balancing in the background, or you may not want to worry about auto scaling. You just want to deploy your application and ensure that the back end is handling everything for you. But with that said, we are likely aware as well, if you've been using Kubernetes Engine, that it actually deploys the containers on top of Compute Engine. As a developer, one of the nice things about the Kubernetes engine is that you don't have to worry about scaling, performing rolling updates, or anything like that. It's all handled in the cluster. So with that said, it does reduce some of the work that as a developer you would have to deal with in an environment that doesn't have a managed service. We probably know what a pool is, but for those that are newer to the cloud, for example, a pool when it comes to Kubernetes is basically what it's going to have: virtual machines that are part of a pool. And once again, the pool is being used to organise our containers. Now, from a deployment perspective, we're going to talk a lot more about this throughout the course because, as developers, we need to know the pieces and parts of Google Cloud and how they fit together. However, I just want to point out here that the container engine is, of course, Kubernetes Engine. now just a little bit older, with the name swapped out. But basically, again, we could use our DevOps services as part of a pipeline and also deploy our containers on top of Kubernetes' engine. And here's our load balancing and also using, for example, maybe an on-premises service or an off-premises service that we're using with, for example, Spinnaker. So we have a lot of flexibility in deploying our applications into containers. When it comes to determining whether we use App Engine or Cuba, it really just comes down to the use case. We are, of course, aware that we can deploy containers with AppEngine flexible and the standard versions of Sandbox, as you are probably aware. Now, the main use case is really just a little more focused. How do we want to scale? Do we want to extend on premises or not? Do we need to have a specific capacity? Do we want to have our services managed by App Engine or not? It's really about the use case, and the answer is yes. We could deploy containers on Kubernetes Engine, and we could deploy them on App Engine as well. When it comes to scaling, we want to be aware that when we deploy Kubernetes Engine, we set up our cluster to auto scale.It's going to just deploy resources that are needed. Now, currently at the time of writing, the cluster auto scaler supports up to 1000 nodes and can run 30 pods each, as well as some other little tidbits around scaling down, for example. Now, in the course, we'll go over some of the specifics of scaling, introducing security federation, and so on. For the purposes of this module, we're going to keep it fairly basic. When it comes to deploying clusters, we want to be aware that the cluster can consist of one cluster master and, of course, multiple worker machines, which are known as nodes. The master and node machines run the cluster orchestration system. Now, when we deploy a cluster, you'll see that it's fairly straightforward. What we would do first is go over to Kubernetes Engine and deploy a cluster, specifying the number of nodes and any variables that we would want as part of the cluster. Now, the way these resources are calculated is sort of interesting, and you want to know this for the exam. We're going to talk about more of this throughout the course, but we just want to be aware that it is allocatable. And this means when we consider resources, we want to look at the term "Cuba," for example, as allocatable. This is basically capacity less reserved space and minus the eviction threshold. And again, we'll get into more of the complexities around this throughout the course, specifically around the deployment part of the course. But I just wanted to specify that as something we'll get into. Now, when it comes to deployments as well, we just want to be aware that there are some tasks that we will likely want to handle, whether by inspecting, automating, or deleting them. That's really the main task that we'll be looking at when it comes to deployments; we want to be aware as well that there are three states in the life cycle, and this is probably something we're already familiar with, but just in case it's basically new to you, let's say, or you just don't remember whether it's progressing, completed, or failed. So when we deploy, for example, a template, we're going to get back progressing, completed, or failed; that's really what we should expect and nothing more. Now for the test. Again, this is more an introduction to the basics around what we can expect on the developer exam. Of course, we'll have a lot more test tips on Cubanete's engine throughout the course. But I just wanted to highlight some of the obvious. The exam is going to already expect that you know how to define and, basically, there are no containers, pods, or clusters. In other words, there's not going to be any explanation of what they are in the exam. So we need to go into the exam knowing what the terms mean. And then, when it comes to a Podor volume again, how does this all work? We need to know that. We do need to know that Kubernetes runs Docker containers. And then, from a design perspective, we need to also understand how this fits in with a CI pipeline as well. And, of course, we'll go over this in more detail later, but for now, be aware of how some Google cloud services fit into the Kubernetes engine and service lifecycle. And in the coming days of the course, I'll be talking about what I call "complementary services to Cuba." So let's go ahead and move on. We have a lot more to cover.