‫So let's practice using Amplify.
‫And the Amplify console takes us in different directions
‫so we get started and here we have multiple options,
‫we can either do Amplify Studio to build an app
‫or Amplify Hosting to host an app.
‫And so currently we're going to build an app using here.
‫So I'll just click on, I call it DemoApp
‫and then confirm the deployment.
‫So this is going to create an Amplify app
‫using Amplify Studio.
‫And this will be similar to what we did if we used the CLI,
‫the Amplify CLI to set up our Amplify app,
‫but I like the console in the Studio because well,
‫it shows you what is happening
‫and it will help you understand
‫what the Amplify service is about.
‫So we are now in our DemoApp
‫and we have actually two things.
‫So we have the backend environments and this is staging,
‫and this is where we're going to set up everything.
‫And we'll launch the Studio
‫to go into the staging environments
‫but also you can get hosting environments
‫and you can connect actually your source code
‫from a Git Repo,
‫and then you're going to host these as a web app in minutes.
‫Okay so it could be GitHub, Bitbucket, GitLab, CodeCommit
‫or without a Git provider.
‫So we are in the backend environment
‫and I launched my Amplify Studio.
‫And the idea is that
‫here you can set-up a lot of things for Amplify.
‫So as I said remember, Amplify allows you to integrate
‫with different services in the backend of AWS.
‫And this is where we see it.
‫So I'm just going to do an overview,
‫I won't go into each of those one by one,
‫as you can see we can manage the content
‫and for this we can edit the data model.
‫So if we add a model
‫for example, I call these ones Users and there is an ID
‫and then there is for example, a name it's a string,
‫and then an age, it's an int.
‫Okay and then we Save and Deploy.
‫So this is actually going to create for us a DynamoDB table.
‫So if I go back into my content,
‫I go here and I'll open DynamoDB.
‫And go to my tables, let's just wait a little bit.
‫So while this is deploying,
‫let me show you what is happening.
‫So if you go in CloudFormation,
‫it turns out that your Amplify deployments
‫are going to be powered by CloudFormation.
‫And as you can see here, my Amplify Stacks can be nested
‫within my main Amplify Demo App Station Stack.
‫And there are a lot of things
‫that can be happening at the same time, okay?
‫But here it is and you can look at the events,
‫and see the fact that well some updates
‫are happening over time.
‫Okay so let's have a look at DynamoDB now.
‫And as you can see,
‫two tables were created by CloudFormation
‫and therefore Amplify.
‫And we have the AmplifyDataStore,
‫which is representing data for the Amplify service,
‫as well as the Users table,
‫which should the user table I created,
‫which contains my partition key to be id(String) okay?
‫And so it's going to take some time until it shows.
‫And the last thing I want to show you here
‫is the fact that alongside the DynamoDB table that we have,
‫there is the appsync service that has been created.
‫And this appsync service is actually
‫getting an API called DemoApp-staging
‫and if we look at this API itself
‫the Schema has been defined as my users,
‫which has an ID, a name, and an age.
‫So this is where we defined it in our Amplify Studio.
‫And in terms of data sources,
‫you can see that it is connected
‫to the Amazon DynamoDB table.
‫So from within Amplify
‫and if you go to contents right now, this is done.
‫Okay so if you go to the data from within Amplify
‫we know that we were creating a DynamoDB table,
‫a GraphQL schema for appsync and so on.
‫And so therefore we can start to manage our app data, okay?
‫And if you wanted to you could create,
‫and Users is just a user table.
‫Obviously we have a better way of managing users,
‫which is user management but you could go ahead here
‫and actually add some data into Users table.
‫For example, I click here and I say name is Stephane,
‫and age is, hey you don't know, let's say 40.
‫(Instructor chuckles)
‫Then we save this user.
‫And as you can see, the user is created.
‫Okay and if you go into our DynamoDB table,
‫and we do Explore Table Items,
‫the User is appearing right here.
‫And we have more fields than what we know.
‫We have the type name, we have the last change date,
‫the version, the age, the created date,
‫the name, and the updated date.
‫So a lot more complex than what we're doing
‫if you were to create our DynamoDB table on our own.
‫So this is for the content and the data,
‫then we have user management
‫and so if we set up authentication,
‫this is actually going to either
‫set up from scratch Cognito or we can reuse a Cognito.
‫But we can just set up from scratch
‫and therefore you can say,
‫okay how do you want people to log in?
‫So people have login by email,
‫but we can have phone number,
‫Facebook, Google, Amazon, or Apple.
‫Whether or not we want multifactor authentication.
‫And setting up the sign up
‫so which attributes do we want to capture?
‫Whether it be email address and so on.
‫And then once we do deploy, as you can expect
‫it is going to use CloudFormation
‫to create a Cognito user pool for us.
‫For storage, well you can set it up
‫and it's going to set up storage
‫backed up Amazon S3.
‫So again, this would be a setup for you to do.
‫Functions would create Lambda functions
‫directly from within Amplify.
‫GraphQL API is appsync.
‫REST API is going to be Lambda functions on DynamoDB.
‫Analytics is going to use other services
‫such as Kinesis or Pinpoint to capture some data.
‫Predictions using machine learning.
‫Interaction using the chatbot service from AWS.
‫Notifications is going to use Pinpoints
‫and SNS in the end, okay?
‫So as you can see, this is all from Amplify Studio
‫and then we can also create UI tools using Amplify.
‫And the idea is that you just design your Amplify file.
‫And then for example, your login, your buttons
‫your data interaction are contained within these libraries.
‫So just to give you an overview
‫but you can see Amplify Studio
‫and Amplify contains a lot of different things
‫that allow us to really integrate
‫all these AWS services together
‫and speed up the time to go in production.
‫And so as you can see,
‫data model is done,
‫we could edit and app.
‫Edit and do the app content.
‫We can configure login and sign up,
‫and then we do the UI, and then we will deploy.
‫But obviously I won't do all these things,
‫this was just and overview
‫and Amplify takes a lot of time to learn just on its own
‫Okay so when you're done, you can just delete the app.
‫You just type the delete keyword.
‫And what's going to happen
‫is that the app is going to be deleted.
‫And the CloudFormation Stack itself is going to be deleted
‫and everything will be clean up for us okay?
‫So that's it for this lecture,
‫I hope you liked it and I will see you in the next lecture.