1
00:00:02,130 --> 00:00:05,250
So to deploy our pushed React front end

2
00:00:05,250 --> 00:00:08,740
to ECS, I'll go back to my clusters

3
00:00:08,740 --> 00:00:10,880
or to my Task Definitions,

4
00:00:10,880 --> 00:00:13,450
go to my latest task revision here

5
00:00:13,450 --> 00:00:14,860
and create a new one

6
00:00:15,800 --> 00:00:18,280
because I now wanna add a new container.

7
00:00:18,280 --> 00:00:21,660
And therefore, here, in the Container Definitions part,

8
00:00:21,660 --> 00:00:23,520
we click Add container.

9
00:00:23,520 --> 00:00:25,370
And give it any name of your choice.

10
00:00:25,370 --> 00:00:26,720
I'll name it goals-frontend

11
00:00:27,620 --> 00:00:31,050
and then we wanna use the image we just pushed.

12
00:00:31,050 --> 00:00:34,970
In my case academind/goals-react.

13
00:00:34,970 --> 00:00:37,723
Of course, use your repository name here.

14
00:00:39,530 --> 00:00:41,610
Now, we wanna map port 80

15
00:00:41,610 --> 00:00:45,660
because this image does expose port 80, right?

16
00:00:45,660 --> 00:00:46,977
That's what we set up there.

17
00:00:46,977 --> 00:00:50,100
So we wanna map that here.

18
00:00:50,100 --> 00:00:52,120
We don't need to do anything special here

19
00:00:52,120 --> 00:00:54,270
for the health checks.

20
00:00:54,270 --> 00:00:55,650
For environment variables,

21
00:00:55,650 --> 00:00:58,150
we also don't need to pass anything in

22
00:00:58,150 --> 00:01:00,800
but we can actually do something here

23
00:01:00,800 --> 00:01:03,680
on the Startup Dependency Ordering.

24
00:01:03,680 --> 00:01:05,950
We could have done that before with Node

25
00:01:05,950 --> 00:01:08,110
and the Mongo container as well

26
00:01:08,110 --> 00:01:10,214
but now I would say it also makes sense.

27
00:01:10,214 --> 00:01:14,500
We could ensure that goals-backend should be launched first

28
00:01:14,500 --> 00:01:18,230
so that this is running successfully.

29
00:01:18,230 --> 00:01:20,530
That it was started successfully

30
00:01:20,530 --> 00:01:23,000
before we start this container

31
00:01:23,000 --> 00:01:25,660
because this application won't really work,

32
00:01:25,660 --> 00:01:27,510
this front end won't really work

33
00:01:27,510 --> 00:01:29,920
if there is no backend to talk to.

34
00:01:29,920 --> 00:01:31,970
You don't need to add this

35
00:01:31,970 --> 00:01:34,310
but I wanna show you that you can configure this

36
00:01:34,310 --> 00:01:35,740
on ECS as well.

37
00:01:35,740 --> 00:01:37,770
So that's why I'm doing it here.

38
00:01:37,770 --> 00:01:40,140
Now, we don't need any network settings here.

39
00:01:40,140 --> 00:01:41,950
And we don't need any volumes

40
00:01:41,950 --> 00:01:44,010
and therefore, we can click Add.

41
00:01:44,010 --> 00:01:46,480
Now this container definition is added

42
00:01:46,480 --> 00:01:51,480
and now with that, we can create this revision.

43
00:01:51,900 --> 00:01:55,720
But you'll notice that we now have a problem here.

44
00:01:55,720 --> 00:01:58,820
This button is grayed out

45
00:01:58,820 --> 00:02:01,890
and we can see the reason for this problem up there.

46
00:02:01,890 --> 00:02:05,100
We're mapping two containers to port 80.

47
00:02:05,100 --> 00:02:08,850
Both goals-backend and goals-frontend

48
00:02:08,850 --> 00:02:11,760
are mapped to port 80.

49
00:02:11,760 --> 00:02:14,180
And within the same task,

50
00:02:14,180 --> 00:02:16,090
this is not possible.

51
00:02:16,090 --> 00:02:20,580
Only one container may be listening to port 80,

52
00:02:20,580 --> 00:02:22,040
which makes sense I guess.

53
00:02:22,040 --> 00:02:26,505
How would AWS and the load balancer know

54
00:02:26,505 --> 00:02:28,590
to which container a request

55
00:02:28,590 --> 00:02:31,310
should be forwarded otherwise, right?

56
00:02:31,310 --> 00:02:35,470
Now, there are a couple of things you could do

57
00:02:35,470 --> 00:02:39,640
to ensure that this all works again.

58
00:02:39,640 --> 00:02:42,780
We could try to merge backend and frontend

59
00:02:42,780 --> 00:02:44,920
into one container.

60
00:02:44,920 --> 00:02:48,070
After all, our backend already has a Node server,

61
00:02:48,070 --> 00:02:50,680
so we would also use this node server

62
00:02:50,680 --> 00:02:52,963
to serve our front end application.

63
00:02:53,890 --> 00:02:56,980
We could also expose the backend on a different port

64
00:02:56,980 --> 00:02:59,102
so that we don't have a port clash.

65
00:02:59,102 --> 00:03:01,920
But I don't like the different port idea

66
00:03:01,920 --> 00:03:05,080
because having a port other than 80 is a bit confusing.

67
00:03:05,080 --> 00:03:07,260
And having one merged container

68
00:03:07,260 --> 00:03:10,310
instead of two would be absolutely fine

69
00:03:10,310 --> 00:03:13,270
but I wanna also show you how you can build

70
00:03:13,270 --> 00:03:15,360
and deploy multiple containers.

71
00:03:15,360 --> 00:03:18,763
So I will stick to this standalone frontend container.

72
00:03:19,730 --> 00:03:23,530
But still, there won't be a way of hosting them both

73
00:03:23,530 --> 00:03:25,460
in the same ECS task.

74
00:03:25,460 --> 00:03:28,420
And this is not as easy as restriction.

75
00:03:28,420 --> 00:03:31,270
This is something, which technically can't work.

76
00:03:31,270 --> 00:03:35,340
You can't have two web servers on the same host.

77
00:03:35,340 --> 00:03:37,150
And that is what we would have.

78
00:03:37,150 --> 00:03:40,630
Our Node backend spins up its own web server,

79
00:03:40,630 --> 00:03:42,580
which listens on port 80.

80
00:03:42,580 --> 00:03:46,240
And our Nginx frontend does the same.

81
00:03:46,240 --> 00:03:50,540
And two web servers on the same host technically won't work.

82
00:03:50,540 --> 00:03:53,950
So here, when we talk about ECS,

83
00:03:53,950 --> 00:03:56,750
we therefore need different tasks.

84
00:03:56,750 --> 00:04:00,000
So we need to create a new task definition

85
00:04:00,000 --> 00:04:04,090
in addition to the goals task definition we already have.

86
00:04:04,090 --> 00:04:06,570
Now, I will stick to Fargate here.

87
00:04:06,570 --> 00:04:11,423
And name this one goals-react or goals-frontend.

88
00:04:13,010 --> 00:04:16,244
I will use the same task role as I did for the backend.

89
00:04:16,244 --> 00:04:20,980
And I will also assign the minimum amount

90
00:04:20,980 --> 00:04:23,283
of CPU and memory here.

91
00:04:24,390 --> 00:04:28,940
Now, it's here where I wanna add my goals-react container,

92
00:04:28,940 --> 00:04:33,610
so this academind/goals-react container we pushed

93
00:04:33,610 --> 00:04:35,973
to Docker Hub before.

94
00:04:37,780 --> 00:04:40,420
Here, I now wanna map port 80

95
00:04:40,420 --> 00:04:42,300
and here, since it's a new task

96
00:04:42,300 --> 00:04:44,820
and a new process, this will work.

97
00:04:44,820 --> 00:04:47,470
This also means that this task,

98
00:04:47,470 --> 00:04:49,960
this service which will run the task later

99
00:04:49,960 --> 00:04:52,320
will have it's own URL.

100
00:04:52,320 --> 00:04:56,764
We'll now have two different URLs for frontend and backend.

101
00:04:56,764 --> 00:04:59,830
Now, we can leave all the other settings here

102
00:04:59,830 --> 00:05:01,170
the way they are.

103
00:05:01,170 --> 00:05:02,970
And click Add.

104
00:05:02,970 --> 00:05:06,363
And we can now create this task here.

105
00:05:07,200 --> 00:05:09,260
So now we can view this task definition

106
00:05:09,260 --> 00:05:12,270
and create a service based on this task.

107
00:05:12,270 --> 00:05:13,753
But before we do that,

108
00:05:13,753 --> 00:05:17,400
let's actually briefly go back to our code.

109
00:05:17,400 --> 00:05:21,570
I just mentioned that if we now do use two different tasks,

110
00:05:21,570 --> 00:05:24,170
we'll have two different URLs.

111
00:05:24,170 --> 00:05:26,198
And that means that my solution,

112
00:05:26,198 --> 00:05:30,120
which was to omit the domain here

113
00:05:30,120 --> 00:05:33,630
and just rely on this being sent to localhost

114
00:05:33,630 --> 00:05:37,140
won't work anymore because the frontend will now be served

115
00:05:37,140 --> 00:05:39,350
on a different URL than the backend.

116
00:05:39,350 --> 00:05:43,920
So we can't let the browser find that URL automatically.

117
00:05:43,920 --> 00:05:45,230
And as a side note,

118
00:05:45,230 --> 00:05:48,980
this also wouldn't have worked in development locally

119
00:05:48,980 --> 00:05:51,510
when we spin this up in a separate container

120
00:05:51,510 --> 00:05:52,510
than the backend.

121
00:05:52,510 --> 00:05:54,760
And therefore, this runs on a different port

122
00:05:54,760 --> 00:05:59,150
than the backed, port 3000 during development to be precise.

123
00:05:59,150 --> 00:06:03,400
So we need to add a URL back into our code.

124
00:06:03,400 --> 00:06:06,280
And it should be a flexible URL

125
00:06:06,280 --> 00:06:09,130
because it will differ based on the environment

126
00:06:09,130 --> 00:06:10,840
in which we're running.

127
00:06:10,840 --> 00:06:13,690
Now, one important thing to realize here

128
00:06:13,690 --> 00:06:16,610
is that we can't use Docker environment variables

129
00:06:16,610 --> 00:06:17,950
in the React code

130
00:06:17,950 --> 00:06:20,450
because this code is not executed inside

131
00:06:20,450 --> 00:06:23,610
of a Docker container but in a browser.

132
00:06:23,610 --> 00:06:26,330
We can use environment variables in that code

133
00:06:26,330 --> 00:06:28,410
but it's the React build process

134
00:06:28,410 --> 00:06:30,382
which needs to inject them.

135
00:06:30,382 --> 00:06:33,470
And thankfully, this React project setup

136
00:06:33,470 --> 00:06:35,270
supports environment variables.

137
00:06:35,270 --> 00:06:39,490
It just manages them on its own detached from Docker

138
00:06:39,490 --> 00:06:42,090
for the reasons I just explained.

139
00:06:42,090 --> 00:06:45,320
So therefore, we can leverage environment variables here

140
00:06:45,320 --> 00:06:49,150
and we can switch between different URLs here based

141
00:06:49,150 --> 00:06:53,010
on the environment in which this code is being executed

142
00:06:53,010 --> 00:06:55,450
and we could add a constant here

143
00:06:55,450 --> 00:06:57,110
at the top of this file

144
00:06:57,110 --> 00:06:59,073
and name this backendUrl

145
00:07:00,550 --> 00:07:03,244
and this could now hold one of two values based

146
00:07:03,244 --> 00:07:04,740
on the environment

147
00:07:04,740 --> 00:07:06,970
in which this code executes.

148
00:07:06,970 --> 00:07:11,970
And there is a process.env.NODE_ENV environment variable,

149
00:07:12,440 --> 00:07:14,330
which is automatically available,

150
00:07:14,330 --> 00:07:17,340
provided by this React build process.

151
00:07:17,340 --> 00:07:19,940
So provided by the npm start script

152
00:07:19,940 --> 00:07:22,860
and the npm run build script.

153
00:07:22,860 --> 00:07:26,150
And this holds a value of development

154
00:07:26,150 --> 00:07:28,640
if we executed npm start

155
00:07:28,640 --> 00:07:31,150
and a value of production

156
00:07:31,150 --> 00:07:33,303
if we executed the build script.

157
00:07:34,200 --> 00:07:36,930
So we can check if that's development,

158
00:07:36,930 --> 00:07:39,230
if the value in there is development

159
00:07:39,230 --> 00:07:42,460
and in that case, and this is some JavaScript code.

160
00:07:42,460 --> 00:07:43,420
In case you don't know it,

161
00:07:43,420 --> 00:07:45,870
you can just copy and paste it essentially.

162
00:07:45,870 --> 00:07:49,310
So in that case, if we have development as a mode,

163
00:07:49,310 --> 00:07:51,750
I wanna set the URL to

164
00:07:53,980 --> 00:07:57,770
localhost like this,

165
00:07:57,770 --> 00:08:00,230
meaning localhost port 80,

166
00:08:00,230 --> 00:08:02,090
which will refer to the backend container,

167
00:08:02,090 --> 00:08:06,090
which is executed on that host in development.

168
00:08:06,090 --> 00:08:07,920
Otherwise, in production,

169
00:08:07,920 --> 00:08:10,870
we wanna set it to the URL we're going

170
00:08:10,870 --> 00:08:15,493
to run our backend on here on AWS ECS.

171
00:08:16,740 --> 00:08:20,650
And therefore, we need to grab that backend URL

172
00:08:20,650 --> 00:08:24,380
from the load balancer we already created in the past

173
00:08:24,380 --> 00:08:27,630
and we can already create a new load balancer

174
00:08:27,630 --> 00:08:31,200
for the frontend, which will run in its own task

175
00:08:31,200 --> 00:08:36,110
and which will therefore also need its own unchangeable URL

176
00:08:36,110 --> 00:08:38,049
instead of that IP address,

177
00:08:38,049 --> 00:08:41,789
which changes every time we deploy a new task.

178
00:08:41,789 --> 00:08:44,930
So open the EC2 page in a new browser tab

179
00:08:44,930 --> 00:08:47,256
and then here on load balancers,

180
00:08:47,256 --> 00:08:51,460
let's actually add a new load balancer again.

181
00:08:51,460 --> 00:08:54,410
Create a new application load balancer

182
00:08:54,410 --> 00:08:58,420
and I'm going to name it goals-react-lb

183
00:09:00,380 --> 00:09:02,820
and it's internet facing.

184
00:09:02,820 --> 00:09:04,270
This all looks good.

185
00:09:04,270 --> 00:09:06,570
I wanna expose this port.

186
00:09:06,570 --> 00:09:11,570
I wanna add it to the same VPC as my other load balancer

187
00:09:12,340 --> 00:09:15,800
because it will be part of the same cluster.

188
00:09:15,800 --> 00:09:19,000
My new task will be part of the same cluster.

189
00:09:19,000 --> 00:09:21,480
We wanna have the same settings here.

190
00:09:21,480 --> 00:09:24,600
Move on to the next settings.

191
00:09:24,600 --> 00:09:27,420
Attach it to the same security group

192
00:09:27,420 --> 00:09:30,970
as my other load balancer is attached to

193
00:09:30,970 --> 00:09:33,570
and create a new target group here,

194
00:09:33,570 --> 00:09:36,370
which I'm going to name react-tg

195
00:09:37,580 --> 00:09:38,820
and that's the group

196
00:09:38,820 --> 00:09:43,820
to which ECS will automatically add the deployed containers.

197
00:09:44,040 --> 00:09:45,980
The target type should be IP.

198
00:09:45,980 --> 00:09:49,840
And the health check path here may be slash nothing

199
00:09:49,840 --> 00:09:53,430
because the React app will return a valid response

200
00:09:53,430 --> 00:09:54,263
on this path.

201
00:09:55,770 --> 00:09:59,020
With that, we can go to Register Targets

202
00:09:59,020 --> 00:10:01,700
and not enter anything here.

203
00:10:01,700 --> 00:10:05,180
Review this and create this load balancer.

204
00:10:05,180 --> 00:10:08,371
And now that we've got this load balancer created,

205
00:10:08,371 --> 00:10:12,370
we can go to that load balancer configuration

206
00:10:12,370 --> 00:10:15,100
and find its URL here.

207
00:10:15,100 --> 00:10:17,820
And that's the URL which we can later use

208
00:10:17,820 --> 00:10:19,753
to reach our React application.

209
00:10:20,620 --> 00:10:23,410
Now, for our React application code,

210
00:10:23,410 --> 00:10:25,740
we need the backend URL though.

211
00:10:25,740 --> 00:10:28,140
And that's the load balancer we already got.

212
00:10:28,140 --> 00:10:30,120
We will still need the second one though,

213
00:10:30,120 --> 00:10:33,000
so creating it is already a good idea.

214
00:10:33,000 --> 00:10:36,180
But grab the URL, this DNS name

215
00:10:36,180 --> 00:10:39,530
from the first load balancer, which we created a couple

216
00:10:39,530 --> 00:10:41,510
of lectures ago already,

217
00:10:41,510 --> 00:10:46,510
copy that and use that as your production domain.

218
00:10:48,460 --> 00:10:53,030
So that should be http and then this domain.

219
00:10:53,030 --> 00:10:57,440
And with this, I've got this backendUrl,

220
00:10:57,440 --> 00:11:00,370
which can now be used in all these requests

221
00:11:00,370 --> 00:11:02,470
and it will hold the development

222
00:11:02,470 --> 00:11:04,990
or the production URL depending

223
00:11:04,990 --> 00:11:08,420
on this automatically set environment variable,

224
00:11:08,420 --> 00:11:11,650
which is set by the React build process.

225
00:11:11,650 --> 00:11:15,110
So now in all the places where a request is sent,

226
00:11:15,110 --> 00:11:19,730
we wanna use the backendUrl in front of this path,

227
00:11:19,730 --> 00:11:21,383
which is then added thereafter.

228
00:11:23,170 --> 00:11:24,803
So use this here.

229
00:11:27,040 --> 00:11:29,253
Use it here.

230
00:11:31,370 --> 00:11:34,960
And there must be one other request.

231
00:11:34,960 --> 00:11:36,040
Here.

232
00:11:36,040 --> 00:11:38,543
We wanna use backendUrl here as well.

233
00:11:39,500 --> 00:11:41,800
So now with that, we're setting this.

234
00:11:41,800 --> 00:11:45,230
We now also already crated all the load balancers we need

235
00:11:45,230 --> 00:11:49,620
and now we can finally rebuild this frontend image,

236
00:11:49,620 --> 00:11:51,170
push it to Docker Hub

237
00:11:51,170 --> 00:11:53,530
and then start our service based

238
00:11:53,530 --> 00:11:55,593
on the task that uses that image.

239
00:11:57,000 --> 00:11:59,880
So let's rebuild this frontend image

240
00:11:59,880 --> 00:12:01,900
with the docker build command pointing

241
00:12:01,900 --> 00:12:03,963
at the Dockerfile.prod file.

242
00:12:05,780 --> 00:12:10,160
And push the updated image to Docker Hub thereafter.

243
00:12:10,160 --> 00:12:12,423
Using that updated source code in the end.

244
00:12:13,710 --> 00:12:17,710
And now with that, we can close the EC2 Management Console,

245
00:12:17,710 --> 00:12:19,570
go back to ECS.

246
00:12:19,570 --> 00:12:22,020
There we already created our task

247
00:12:22,020 --> 00:12:25,850
and now we can create a service based on that task.

248
00:12:25,850 --> 00:12:28,343
We wanna use Fargate as our launch type.

249
00:12:29,270 --> 00:12:31,580
Use our goals-app cluster.

250
00:12:31,580 --> 00:12:34,570
Give this service a name of goals-react.

251
00:12:34,570 --> 00:12:37,000
Set the number of tasks to one.

252
00:12:37,000 --> 00:12:38,733
Use rolling updates.

253
00:12:40,840 --> 00:12:42,420
And on the next page,

254
00:12:42,420 --> 00:12:45,580
we wanna add the two subnets we have

255
00:12:45,580 --> 00:12:48,173
in this VPC our cluster provides.

256
00:12:49,150 --> 00:12:52,030
On security group, we can actually edit this

257
00:12:52,030 --> 00:12:54,000
and use an existing one,

258
00:12:54,000 --> 00:12:56,270
which already is exposing port 80,

259
00:12:56,270 --> 00:12:58,610
which is exactly what we need here.

260
00:12:58,610 --> 00:13:02,361
We wanna have auto-assign public IP enabled.

261
00:13:02,361 --> 00:13:06,460
Then add an application load balancer here

262
00:13:07,800 --> 00:13:12,800
and choose that goals-react load balancer we just created.

263
00:13:12,860 --> 00:13:16,453
And yep, click Add to load balancer here.

264
00:13:18,360 --> 00:13:21,893
Choose the React target group under Target group name.

265
00:13:22,900 --> 00:13:27,190
We'll leave all the other settings the way they are.

266
00:13:27,190 --> 00:13:28,453
Click Next step.

267
00:13:29,450 --> 00:13:31,000
Leave the settings here.

268
00:13:31,000 --> 00:13:33,940
Click Next step and create this service.

269
00:13:33,940 --> 00:13:36,940
And this will now start our frontend container

270
00:13:36,940 --> 00:13:40,050
and frontend task therefore in a new service,

271
00:13:40,050 --> 00:13:42,420
which now runs side by side

272
00:13:42,420 --> 00:13:45,740
with our goals service, which is the backend.

273
00:13:45,740 --> 00:13:49,900
So now we'll have that frontend service up and running too.

274
00:13:49,900 --> 00:13:51,830
At least soon we'll have that.

275
00:13:51,830 --> 00:13:55,150
And if everything worked correctly,

276
00:13:55,150 --> 00:13:57,620
we should be able to use this service

277
00:13:57,620 --> 00:14:00,163
to then send requests to our backend.

278
00:14:01,070 --> 00:14:04,530
So let's wait for this to be up and running

279
00:14:04,530 --> 00:14:08,690
and let's then use this load balancer URL

280
00:14:08,690 --> 00:14:11,620
of the newly created load balancer

281
00:14:11,620 --> 00:14:15,080
because whilst the IPO of our task will change

282
00:14:15,080 --> 00:14:17,900
with every new deployment, you already learned

283
00:14:17,900 --> 00:14:20,720
that load balancers help you get an address,

284
00:14:20,720 --> 00:14:22,280
which never changes.

285
00:14:22,280 --> 00:14:25,080
And of course, that address can also be bound

286
00:14:25,080 --> 00:14:27,150
to any domain of your choice then.

287
00:14:27,150 --> 00:14:28,560
And if I hit enter here.

288
00:14:28,560 --> 00:14:29,470
That's looking good.

289
00:14:29,470 --> 00:14:31,360
I see my goals app

290
00:14:31,360 --> 00:14:33,700
and it already loads that goal,

291
00:14:33,700 --> 00:14:36,900
which we added manually with Postman

292
00:14:36,900 --> 00:14:39,563
to our backend before.

293
00:14:40,580 --> 00:14:42,672
So if I now add another goal here,

294
00:14:42,672 --> 00:14:44,540
that's also showing up

295
00:14:44,540 --> 00:14:46,680
and it's also there if I reload.

296
00:14:46,680 --> 00:14:48,433
And I can also delete a goal.

297
00:14:48,433 --> 00:14:50,130
And that all works

298
00:14:50,130 --> 00:14:54,100
and this application, therefore works as intended.

299
00:14:54,100 --> 00:14:55,260
So with that,

300
00:14:55,260 --> 00:14:58,880
we now successfully deployed another container.

301
00:14:58,880 --> 00:15:02,530
In this case, since it also exposes a web server

302
00:15:02,530 --> 00:15:04,230
in a different task,

303
00:15:04,230 --> 00:15:06,240
if it wouldn't expose a web server,

304
00:15:06,240 --> 00:15:09,500
if it would just be another container working together

305
00:15:09,500 --> 00:15:11,130
with our Node API, for example,

306
00:15:11,130 --> 00:15:15,790
if we had it before with our MongoDB container

307
00:15:15,790 --> 00:15:18,350
before we switched to MongoDB Atlas,

308
00:15:18,350 --> 00:15:20,950
we could have also deployed it in the same task

309
00:15:20,950 --> 00:15:22,450
as the backend.

310
00:15:22,450 --> 00:15:24,610
But since we now have two web servers,

311
00:15:24,610 --> 00:15:27,840
we need two different tasks and services therefore,

312
00:15:27,840 --> 00:15:30,268
and therefore, we have two different domains.

313
00:15:30,268 --> 00:15:32,569
But this is how we can deploy this

314
00:15:32,569 --> 00:15:35,340
and therefore, this is also an example

315
00:15:35,340 --> 00:15:38,270
how multi-container projects could be split up

316
00:15:38,270 --> 00:15:42,670
across multiple hosts, multiple tasks in this case,

317
00:15:42,670 --> 00:15:44,610
with multiple URLs

318
00:15:44,610 --> 00:15:47,940
and how you could implement that with AWS ECS

319
00:15:47,940 --> 00:15:51,713
and which problem you should keep in mind in such cases.

