Hello, Myself Satish Halange, Assistant Professor, Department of Civil Engineering, Vulture Institute of Technology, Swarapu. In today's session, we are going to see regarding the formulation of the problem in the linear programming problem for the minimize case. At the end of the session, the learner will be able to convert the real-world problem into the mathematical form that is the linear programming problem. Here, let's see what is the linear programming problem. It's a mathematical modeling technique in which the following terms are involved. First one is objective function. It may be of a maximizing case or it may be of a minimizing case. And next comes regarding the decision variables which are involved in the particular example or the problem which are given the restriction that is the non-negative variables we say. The objective of learning of the linear programming problem is to maximize the profit or you can say the benefits or the production or to minimize the time requirement for the manufacturing or minimize the wastage of the resource which is required for the manufacturing of the product, etc. Now coming to the point of today's session, the formulation of the problem in the linear programming problem. The linear programming problems can be solved by the following techniques that is by the graphical method, simplex method or big M method or two phase method. Now steps involved in the formulation of the problem in the linear programming problem are as follow. Step one, we have to observe, study and understand the real-world problem. We have to identify the correct problem of the case and we have to describe the objective function. After this, we have to go for the defining the decisions variables involved in the problem. The decision variables are always help us to define the values in the quantitative value. And we have to go to the next step and we have to define the objective function equation by using the decision variables. We have to write the case of the particular problem. It may be the maximize case or the minimize case. Now next come step number five. Once we have identified the objective of the particular problem, we have to define these constraints or the limitations associated with the example. The limitations or you can say the constraints set equations are in the equality form or inequality forms. And finally we have to give the restrictions to the particular variables. That is see the example, here the multiple is there which is having the case study of the water supply system. Basically they are using two methodology. One is the gravitational methodology and second one is the mechanical boosting or you can boosters states for the supplying of the water. And when we see this description, they are conducting the research and they are saying that the particular overall description that the pressure expressed by the gravitational method and the mechanical pumping station in the entire municipalities were put at the 2 kN per m2 and 8 kN per m2 respectively. And the municipality has three pumping states that is A, B and C. There are three locations pumping states A, B and C and the pumping state A is expressed to have the combined pressure of not more than 24 kN per m2. And the housing state B should have the pressure of not more than 130 kN per m2. And the house state C will have the pressure of magnitude not less than 12 kN per m2. This are the particular limitations which are defined for the housing state A, B and C regarding the pressure. Means here these are the pressures, minimum pressures or you can say limitations of pressures defined to get the proper supply of the water by the supplied apartment. Now this table is giving you overall picture of the pressure by the gravitational method and the mechanical booster states for the each housing state A, B and C. Now first step as we have seen we have identified that in this present case the municipality or you can say municipal is instead interstate to have the betterment water system or you can say increase the distribution of water properly by two methodology one is of gravitational method and by the mechanical method. As they are facing the problem by the only by the gravitational method. So we have observed the particular problem, we have studied what the exactly the example or the problem requirement is there and we have understood. Now we have to define what is our objective of the particular problem, yes in the present case the main objective of the particular municipality water system is to minimize the pressure requirement in the municipality. So we have to define the variables. Now after knowing the what the particular problem is there and what is the objective and we have to move towards the finalizing the decision variables. Now the municipality is one to supply the water by gravitational method and the by the mechanical booster states. So let us assign x1 is the variable of gravitational method and x2 is the variable of mechanical booster state. Now once we have defined the variables of the problem that is of the related to the gravitational method and the mechanical method we have to move towards the objective function and we have to write the objective function equation. The objective function equation is what to minimize the pressure. So minimization case it is there and z is equal to 2x1 plus 8x2. How it is been defined you just see what they are saying just go through the overall particular description the pressure expected by the gravitational method and the mechanical pumping station in the entire municipality where put up to the 2 kilo Newton per meter square and 8 kilo Newton per meter square we have to define the constraints or you can say set of constraints. Here after identifying the constraints are what the constraints are particular availability of the pressure with each pump stations or you can say housing stations. Here housing is state A when we move towards the example here the description is saying the municipality has 3 housing states A B and C and housing state A is expected to have combined pressure of not more than 24 kilo Newton per meter square. So this by using this table for housing state 1 A or you can say A 1x1 plus 2x2 is here what they are saying for the first housing station it should not more than means the equation will be 1x1 plus 2x2 less than or equal to 24 because 24 is the maximum it should not be more than 24. So similarly for the house is standing B when we have seen this problem the housing state B should have the pressure of not more than 130 kilo Newton per meter square. So 7x1 plus 6x2 is less than or equal to 132 similarly for the house is states C x1 plus 2x2 greater than or equal to 12 because here the when we see the description the house is state C will have the pressure of magnitude not less than they are saying means it should not be have the pressure less than 12 kilo Newton per meter square. So by using this table for housing state C 1x1 plus 2x2 it should be greater than or equal to 12 these are the three set of constraints available with this particular problem and finally we have to use the restrictions signed to the particular variables decision variables x1 and x2 is greater than or equal to 0. So this is overall formula example objective function is equal to minimize z is equal to 2x1 plus 8x2 subjected to the constraint x1 plus 2x2 less than or equal to 24 for sub or house is state A and 7x1 plus 6x2 less than or equal to 132 for house is state B and x1 plus 2x2 greater than or equal to 12 for house is state C by the restriction of the sign to that both of the variables. Just answer this particular question hope so you have selected the correct answer for the example these are the references for the today's session thank you.


All right. Hi everybody. My name is Nidhi Siddhanand and I work as an architect at Wal-Mart Labs Bangalore. I hope you've had great talk so far and you're back from tea. So just want to talk about microfrontend architecture and before I do that I want to set some context. So my team works on the discovery experience in walmart.com, which are the landing pages that customers see when they come to Wal-Mart either directly or via SEO or SEM. Typically these are homepage, search and browse, product page and so on and so forth. This talk microfrontend architecture is basically talking about the fitment widget on the product page as an example. And the goal of this talk is to give you a sense of why and how we adopted this architecture and hopefully you can relate this back to your own use cases or think about it in your future projects. Right. And before I sort of delve into the talk, I just want to give you some context. So walmart.com sells products across multiple categories which include home, fashion, everyday living, things like diapers, shampoos and also auto parts and products that are specifically for the enthusiast and professional. So we have a diverse set of customers who come into Wal-Mart and the way you would serve a customer who is trying to shop for clothes is different from whoever is trying to buy diapers because in the case of diapers and shampoos you know exactly which brand you're going to buy and you're not really looking for a whole lot of other things whereas in fashion and other areas like electronics you want to get more information about the product, what are the alternatives. So the experience kind of changes for these various pages depending on the category. So it's dynamic for a category.  We are distributed between US and India. We're roughly around 70 engineers and at any one point in time we're working on 10 parallel initiatives which include both business and engineering requirements. We are broadly divided into a core and a specialized experience. So the specialized experience is as I just mentioned that fashion product page will look slightly different from something like a core product page and we largely work off the same core base. We share across all these web apps we share around 10 third party libraries and 10 in-house libraries across the board and we do have automation but we're not 100% automation covered so that's the other challenge. Because we are the landing pages we are also very sensitive to performance. Metrics like TTFP first meaningful paint are things that we really care about and our page views are roughly around 5000 page views per minute. And adding experience like the fitment widget on the product page can be upward of 120 files for that experience only and if you count the number of react components, the reducers, the API integration, your configuration files and if you look at unit tests, automation tests, analytics code, all of these things really add up to a lot of code that you're adding and we are roughly around 6000 lines of additional code just for putting a fitment widget on a product page. So we do have a process now you might be thinking large scale web development you must be having the processes and all and this probably looks very similar to what you've got in your current companies is that we do have guidelines on coding conventions how to raise PRs. We have Git pre-commit hooks that run your lint, your unit test as well as sometimes it runs automation as well and we have Slack channels for review where you post your PR and there's a pool of reviewers for a particular day who will pick up your PR and review it. Now the thing about that is that reviewers need not necessarily be working on the same initiative or be from the same team they focus more on the technical aspects and less on the functional aspects. So typically your PR can go up to two to three days for a review depending on which part of the code you're touching and depending on how much context the reviewer has how much bandwidth they have etc. So coming to this we wanted to be more efficient in the way we were developing things and this is not across the board this is I'm going to be talking about a specific example. So in the light of that what is a micro front-end and this is not a textbook definition either this is more how we kind of define it is it's a fragment or a component that can be reused and embedded into any page. It can be rendered on the client and server and this is important because across all these web apps we have some pages that are client-side rendered some pages which are really rendered on the server side and hydrated on the client side and then there's a combination of both. So we want to make sure that it supports both formats. It has 80% of independent life cycle and the reason we need that is that we can automate this independently we can ship this independently so it should have an independent life cycle and it has medium to heavy functionality so if you are adding code roughly which is around 20 components and you know reduces or 20 modules that's fairly heavy functionality that you are adding to an app. So while your micro fragment or component can act independently and it can be executed independently it really decides its behavior and UX from the host page. So the host page provides some context so that the fragment's behavior is determined by the host context and it has to adhere to the SLAs specified by the host context which is typically your TTFB, FMP and in our case we track the CATF which is the customer ATF whatever the customer sees when they land and this we track week on week in terms of how it's progressing whether it degrades so adding more and more fragments can sometimes you know those metrics can get compromised if you're not very careful with it. So we also say that fragments should be maintained as a library or as a service so essentially you can embed a fragment using just a script tag with a particular version of that script or you can actually make a service call to a remote service and that will give you the HTML that the fragment has to display. So it can be maintained independently as a service or a library. So in the light of this when you are like developing a fragment and there is a host web app there are some constraints that the host web app kind of places on fragment and the team that's developing the fragment is one that should not add a lot of code bloat so when you're developing a fragment and you should not have like you know 10-12 different files coming in it should align to the performance budget and most web apps actually know what performance budget they're tracking should reuse common versions of the same framework so this is also very important because if you are developing a fragment and the host web app let's say is on React 15 and you're on React 16 if this is going to be on the client side you'll download additional versions of React which is not needed. Integration should be limited to a few lines of code so we want to make sure that we encapsulate it in a way that the host web app is only dealing with some interfaces. So at this point you're probably wondering why do I have to do all of this stuff? I mean I can handle all of this using code splitting or bundle splitting and I'm sure that most of you have used bundle splitting. A lot of you know libraries support this out of the box so if you've used bundle splitting using routes using webpack entries or even module based bundle splitting using webpack dynamic imports React loadables is similar to that. What it does is that it also has support for server-side render and it also has a progress loader for when your bundle is loading. So React loadables is great to kind of chunk out your JavaScript code and to load them at a later point in time but it doesn't really solve for independent life cycle management so it doesn't tell you how to version it it doesn't tell you how to automate it it doesn't sort of allow you to separately execute it as an independent entity. So coming back what are some of the goals for component developers? So one is your fragment should be configurable because if you're not building a reusable fragment there's really a lot of heavy lifting you're doing to achieve this kind of architecture which doesn't make sense. So you want to ensure that the fragment is configurable that if you change the page in which it's getting embedded into it can accordingly its UX and behavior should change as I mentioned before can be CSR SSR and it doesn't assume anything about it's sorry my this thing is falling off of it. So it doesn't assume anything about the host context so it doesn't try to access DOM elements of your host it just uses event-based communication and I'll get to what libraries we use for this but there are many. You can analyze all the clicks user interaction of this fragment independently so all the beacons all the user clicks all the API calls or API errors performance metrics can be collected independently analyzed independently and as I mentioned it has an independent lifecycle you can release new fragments and the host web app either just gets the latest version or it sticks to a version that it already has. So coming to the specific instance of micro frontend that we have implemented is this is a screenshot of the product page and this is an auto parts product page where you're basically checking whether this windshield wiper needs to fit my car or not. So earlier before we did not have this check fit widget you would buy this and you might have to return it if it doesn't fit. So the reason that this widget is there is to help reduce the number of returns that we are seeing. So essentially what so the widget is basically configurable in that the year make model all of those texts is configured the number of drop-downs is configured and the data that it populates is coming from an API call and there is state management in this widget because you have to click on your then you have to click on make and there is some validation between the two and then finally model and the call to action here is the check fit button over there. So essentially what check fit does is it makes an API call to the back end and tells you whether this fits or not and when you click on a variant like let's say the 22 inch wiper blade this widget then re-renders and make sure that it checks for the right product part. So it talks to the host page to get context of the part saying this is the part that I'm rendering and hence my APIs are specific to this particular product and it listens for changes on the host page in this case when you're clicking on your variant it goes and re-renders. So on the product page what this gives is a binary evaluation of whether yes it fit or no it did not fit but if I put the same widget on the search page what it does is it issues a new search query to narrow it down to items that do fit. So there is so all of that is also configurable so behavior changed but it's configured right. So what are some of the design elements that we incorporated while doing this was one all the scaffolding all the boilerplate code was encapsulated into a node module and we just expose that for the host web apps then we expose an API to determine whether this widget has to be included or not and this we need because whenever we roll out anything we A-B tested extensively so we show the feature to a certain set of customers before it goes to everybody so everything is behind a toggle flag and we support lazy loading of the JS and the CSS. So this is essentially just adding a script tag and a style tag dynamically. So this widget has its own API integration so it doesn't depend on the host context for APIs it does its own API integration. It has its own automation test so it can be automated completely independently and everything is configuration driven as I mentioned before and it communicates with the host only asynchronously using this library called postal JS that is used for publishing messages and subscribing to messages. So coming to the code snippet I don't know if everybody can see it but I'll try to walk you through this. Essentially this is the widget container and this is the bootstrapping part of what the host container is using and this is a react component and the render method here is essentially just assigning a placeholder for this widget and this widget is actually rendered only on the client side but it gets its place where it has to render from the server and before we actually render it we check whether it is enabled or not. Great so there's some I think there's a typo somewhere okay. So essentially after it gets on to the client when the component did and it renders and the component did mount a lifecycle method is called next. It injects the CSS and the JS at that point in time and once the JS has loaded this method executes in which we pass in all the context information to the widget which says hey this is the product page this is the mount point and this is the part and the product that we're looking at. Right so I had mentioned at the start of the talk that we roughly like quite a lot of web apps and we share roughly around 20 libraries between all these web apps. So if you look go through walmart.com we are basically doing route based mini apps so product is one app search and browser is another app home is another app etc. So how do we share libraries between this and how do we do that efficiently I mean if you have to manage 20 libraries across so many teams it can get really hard to do. So what we use is a web pack feature called web pack DLL plugin. What this does is it allows you to consolidate all your dependencies into a manifest file and instead of each web app trying to resolve their own react and load and all of those dependencies they just reference this manifest file and using a complementary plugin and that's the version that they all get so that way it gets easier to maintain. You just have to maintain the versions in this one in this one configuration saying these are the versions of react and redux and common libraries that I'm using. Yeah so this is what the web pack DLL reference plugin is what the web apps are going to use and as you can see I've got like the kernel 1P which is the manifest file that was generated from the previous build. So I have two of them and it just references these so that those versions get maintained otherwise you have a problem of multiple people using different versions of the same library and if it is client side rendered then you're downloading those on the client. Right so communication we use postal JS this has the same semantics as any kind of server side communication you have a channel topics etc. And you use you basically publish a message to your topic and subscribers get the message from that topic and the widget is essentially a JSON configuration so we have dependencies between the nodes that are mentioned in the JSON file. So JSON is a good format for us to define a configuration in which there are dependencies from the from the leaf nodes to the topmost nodes. So this was just a reinforcement of what I'm saying but since I'm kind of going out of time I'll just really run through this really quick and I think I hope you kind of got the idea of when I talked is that first page load request goes to the web app. It just sends a placeholder for the for the widget and the widget then loads off the CSS from the CDN the JS and the CSS from the CDN then it talks to its own services for getting the UI configuration from which it makes API calls. Okay I'll quickly walk through benefits and all so one thing is we are a large team so our PR turnaround came down to one hour from one to two days because we're a small team of engineers. Person knew about the context as well as the technical aspects. AB testing was a whole lot easier because we're just managing all the toggle flags within the fragment at the fragment level and the most important aspect was that a bug fix at the fragment did not require a full page regression on the host app. It just required the fragment to be fully regressed. Yeah so takeaways independent development of page fragments configuration based UX and behavior fragments can be released independently off the main app so that's a huge win. And the thing you need to take care of is also should be orthogonal functionality should not be specific to a particular use case. Hence you have to make sure that there is an independent lifecycle for this that is reusable and reduce risk of failures because you can regress at a fragment level. And some of the downsides are when you've created fragments it can get orphaned because now everything works as as you expect. But there is no one size fits all so there are always use cases that you can get into where your component does not satisfy that requirement. And if you're hosting this separately and having its own API services etc there is the additional cost of infrastructure. Okay so that's all you can reach me over LinkedIn I'll be here if you have any questions and I have the additional reading material here on the slide. Micro front ends by Martin Fowler and the GitHub links for react loadable DLLs as well as the gist to the code that I just showed you. So thank you thanks for being here catch me later. Thanks Nidhi for the wonderful talk.


The session had an experiential learning exercise that was conducted by Zareer Sir and Rajinder Sir today in a similar format, how they are doing it for our children. We had our first session with the parents for the first time in history. What this system is thinking can actually do in that way that we can take care of. Through that small exercise and sharing of that exercise. It's very helpful for parents to open their mind and learn that not a child but parents where the parents lacks. I think that is very very important for parents and this type of work so more and more should be conducted. It's a new exposure to me about a topic that I had been interested in because I am hearing a lot in the world about how this is being employed in order to help the companies to uncover problems and to come up with new solutions. And that they are doing it for the students at the school level I think is a wonderful initiative by GIS and I am really grateful to them for organising this and also to the facilitators Zareer and Rajinder. So voluntarily those parents are asking for more such workshops to be conducted and we see a possibility where parents, teachers, students, principals and everyone can come together and before solving the problems that we have we collectively try to understand what the problem is, understand different beliefs that are creating that problem and then that understanding will help us to bring more sustainable, more lasting solutions. I think the reason why I am saying this is that the new skills that children have to learn are not really about information or about certain procedures, science, life and all that is about how to look at life, how to solve problems, understand themselves, to reflect, to introspect and of tight and rigid boundaries to world of flexibility, to world of possibilities. So this is something which is not going to end with their 10th or 20th degree but I think this is a skill which will hold them good for life.


Hello, this is Pawan Bheman from the CNF integration team. In this demo, we will be taking a look at installing and configuring the Artifactory as a disconnected registry and also as an image store for root FS images and ARCOS images. As Artifactory can host Docker registry, ISO images, Git repos, this becomes really useful as we can host multiple repositories on a single host and Artifactory can be a single point of contact for hosting multiple repositories. So even before we take a look at installing Artifactory, first thing is to have a server which has around at least bare minimum of 400 GB of free space. I have already mirrored the contents, so you can see the available GBs are really less. But essentially we would at least need 400 GB of free space to mirror the registry contents. The rule of thumb for selecting the amount of free space is that it is always better to have more free space in order to accommodate for the future growth of the registry. And here I am using a trial version of Artifactory as we do not have any licenses purchased by our company yet for Artifactory. And once we register for a trial license, we get a link which has the contents of the installer along with the steps to install it. So essentially all we have to do is to go to the link download the turbo image and then follow the steps to install the Artifactory application. So this is the link that I got and then all it does is it downloads the turbo, extracts it and then runs the install command on it. And then we would have to start the Artifactory service on it. We do not need XRA as of now and we do not need to start that. The only thing that we would need to start is the Artifactory service. So let me go over to a new machine and then download the tar ball. We will wait until the download has completed. Now that the tar ball is downloaded, we would need to extract it. Go to the extracted directory and then just run the install script. We will wait for the installation to complete. So the installation has now completed. So now we would need to start the Artifactory service and check its status. Now let us take a look at the status to make sure it is running. So now Artifactory service is running. So now our installation has succeeded. The next thing that we would have to do is to disable the firewall rules to the ports used by Artifactory. We would need to disable firewall rules for port 8080, 8081 and 8082. We would also let us also disable firewall rules for port 80 and 443 as we would be using it later for either HTTP or HTTPS Docker registry that we will be setting up. So let us go ahead and do that. Let us reload it and now we can check if the UI for Artifactory is accessible or not. Basically the UI will be running on port 8082 and the API runs on port 8081. So let us take a look at it. So right now this is the host IP address on which we just installed Artifactory on and this is port 8082 where it is hosting its web service and the username and password are by default created for when we create a trial license and then we can go ahead and change it on our first try. Okay so I guess it was still coming up so it was not taking my password. So that is for setting up a new password and then the next step it will ask for the license key. I have already set up the license on another server and I have mirrored all the images there. In interest of this demo I will be showing the setup for that particular Artifactory server because mirroring everything from scratch might take a few hours. Okay now we can see the UI after applying the trial license. So essentially it has two tabs, one is administration and one is application. So we can see the artifacts and the packages here and in administration we can set IAM security and then take a look at the system blocks and things of that nature which we can see later. And after doing this next thing that we would have to do is to set up CNAME records for the Docker registry and the image store that will be creating that will be creating later. So these CNAME records have to point to the host record that it is pointed on. One thing to note is that it has to be in the same domain as the server host name. So this is important as when creating the registry name it has to match the DNS records that we are creating now. So here I am using the same A record as the one that is configured for the host on which Artifactory is installed. So right here please do not do this. Please create a CNAME record, please create two CNAME records, one for the Docker registry and one for the image store. So once we have done that we would need to install a reverse proxy. So the reason for installing reverse proxy is that on Artifactory there are multiple ways to set up a Docker registry such as direct access, port bindings and subdomain. The prescribed method that Artifactory gives for on-prem environments is to use a reverse proxy and use a subdomain method for creating a Docker registry and hence we would need to install reverse proxy. I have installed Nginx here as a reverse proxy. So here Nginx is already running and one more thing is that we do not have these two directories sites enabled and sites available by default when we installed Nginx. Please go ahead and create these two directories. We would later need these directories in order to set up Artifactory config in them and after we have created these two directories the next thing that we would have to do is to generate certificate. So this certificate is for the Docker registry that we will be creating. One important thing to note here is that we will be creating a wildcard DNS name for the common name while creating the certificate. So this is because we will be using the subdomain method to create the registry. So here you know the DNS thing might be a little confusing at this point but once I show you the HTTP settings for the Docker registry this might get clearer. So I have created the certificate and if we take a look at the CNAME you can see that it is a wildcard DNS entry. So once we have created it we would need to copy it to Etsy Nginx certs and also we would need to copy it to the Provisionary node from which we will be installing the HUB cluster and then we would need to update the address so that this certificate gets updated. So once this step is done the next thing we would be doing is to finally create the Docker registry. So let's go to the Artifactory GUI again and then if we take a look at repositories. So here we have, I have already created two repositories, one for the Docker and one for generic but if I were to create a new registry we need to go to add the repository and click on local repository. So here it has a lot of repository types and for now let's click on the Docker repository and here while giving the repository key which is essentially the name of the local Docker repository that we will be creating. So this part is, the name of the repository key is really important. So this has to be the name preceding the wildcard DNS entry name. So here when I said that I'm using the host name for creating the Docker repository. So this has to be this name service node and that is why we are creating the wildcard DNS entry. So this will be a service node. It says that the repository already exists but essentially we would have to just click on create a repository and once we have done that we would need to have the reverse properties settings accordingly in order to access the repository. So we have to go to the administration tab, Artifactory, click on HTTP settings and then here we have the three methods that I was mentioning about the repository path port and subdomain. So basically I will be clicking on subdomain and the server name expression is automatically filled with the wildcard DNS entry that I was talking about and that is the reason why I was telling you that the domain name of the CNAME and the host name on which it is hosting on should be matching. And here in the reverse proxy settings we have a list of reverse proxy providers and here I selected NGINX and the internal host name gets pre-populated as the IP address of the host on which Artifactory is hosted on and these are the two ports that Artifactory will be using and we already disabled the firewall rules on. And while setting the public server name we would need to set up only the domain name part of this and while accessing the registry the way the Artifactory accesses the registry is the repository name that we gave which is service node and the dot the public server name and again so this is the same as what we gave here for the domain name. And then we can have two options one is to use HTTP and HTTPS ports. So we need to enable both and then for the SLKEY path and SL certificate path so this is where we created our certificate and this is where and we will be giving essentially the path of that particular key and cert file here and we need to click on save and once we have done that Artifactory creates the reverse proxy configuration for this particular settings that we gave so the NGINX config that we need is already created here so all we need to do is copy it and then once we have copied it we need to go to our database host and then create this configuration and sites available so I have already configured this this is based on what we copied and the other thing is we need to enable it so basically in sites enabled we need to create a soft link pointing to sites available and once we have done that we need to restart NGINX service and once it is restarted let us look at the status alright so now NGINX is running without any issues so essentially once we have done this we can check if the registry is working or not so we can check by logging into the registry and see if we are able to log in into it or not so let us do podman login and this is the registry name and please note that it is not 5000 it is 443 that is because in the HTTPS settings that we saw we are using port 443 alright so now we can log in to the registry that we created so we have successfully set up the Docker registry repo for Artifactory so now the next thing that we can do is to mirror the images the OLM images and the OCP release images there are two issues while doing this with Artifactory so one issue is that while using the auth file which has the authentication JSON file for the registries that we are mirroring from that is registry.redact.io or query.io Artifactory somewhat does not like using the pull secret JSON file for that and the other thing is even to authenticate to Artifactory the pull secret does not work by mentioning the login credentials there so while specifying the authentication for Artifactory in the command itself it seems to work and I have seen multiple bugs raised on that and they are opened I will show you what I mean by that so basically while mirroring the images for instance while using a podman push we would need to specify the credentials for Artifactory here as a part of the command itself rather than using a pull secret JSON file in order to do that and the pull secret for accessing query.io or registry.io it is better to put it as a part of the Docker config.json file and because it does not seem to take the pull secret file so by pre loading it here and then using the mirror it seems to work and one more thing that I faced as an issue with Artifactory is that while doing the mirroring after some time Artifactory shows another message as 403 forbidden and does not allow me to log into Artifactory to push the images. One thing that we can work around for that for commands such as OCADM is to specify max per registry as one so basically this is the number of concurrent corrections that OCADM will be using in order to connect to the local registry and the same thing can be done for the same these two things can be done for essentially a scope.io or even OC image mirror so I will show you an example here so I have done the same thing on OC image mirror meaning I gave maximum per registry as one and then while using scope.io there is a way to give the destination credentials here so essentially which is admin password which is the default one while we install the trial version of the Artifactory application. So after adding this I had no issues mirroring the images for Artifactory but even with this I have done the same thing on OC image there was an issue with pulling the images once I installed the hub cluster and that was the same thing in which there were multiple connections to the Artifactory repo and then that prevented the download of images for the hub and the SNO node while taking a look at that I realized that Artifactory is a little buggy in which while having multiple concurrent connections or pulling multiple images there is an issue with the Artifactory cache and then this issue causes a cascading failure in which it considers authentication request as a false authentication request meaning that even with the current authentication credentials the Artifactory considers as a wrong authentication credentials and hence login is denied and this is a very serious issue because essentially the hub or the worker cluster cannot pull images from this registry there are a couple of mitigations for it one way to mitigate it is to just restart Artifactory and it will flush the cache and then once the cache is flushed it works fine so we would need to trigger the mirror again and then do it each time there is an issue with the cache the next step is to have these mitigations already the one for the credentials that we are specifying both for part manage copio and also for catalog mirror or OC image mirror where we are specifying the max per registry as one and along with that we would also need to specify one configuration so which is to essentially not to block the login on in terms of failures of authentication so this is the configuration which is max login block delay as 0 and we would need to set it on Artifactory system properties and there are two places in which the Artifactory system properties are present one is on the wire of the JFrog directory and the other one is on the JFrog directory so the reason why we are doing it is very simple so because we are getting disabled temporarily to login by Artifactory and the caching issue is causing this cascading issue so we can as well you know disable temporary login suspension and that should not block us essentially and this particular mitigation work for me and I have been able to pull the images without any issues after having all these mitigations and these are bugs that are open in Artifactory as of now and it might be fixed by Artifactory in the future but as of now we will be seeing this particular issue and once we have done that I have already mirrored the content of the Docker registry into Artifactory and let us go ahead and take a look at that so if we take a look at the repositories so if we take a look at the artifacts this is the Docker repo so here I have mirrored OLM and then ACM and then the REST and then installer images so this is the repository so right now so we are all good to go with the Docker registry setup the reason I am showing the already mirrored repo is because this will take a few hours to remirror all of this and in interest of this demo this makes it a shorter demo in order to remirror all of this onto Artifactory so now that we have created the Docker registry successfully and we have mirrored the images the next thing to do is to create registry for storing the root fs images for the small iso and also the orcos images for the bootstrap OS image and cluster OS image during the that is needed for the hub cluster installation so in order to do that we will go to repositories again and then we need to add repository and then select local repo and in this we need to select the repository as generic type and here again we would need the repository key to match with the CNAME record that we have created and in my case it is service node 2 as I have already created it it does not take the creation of the new one so essentially once it is created it has to show the repo key and these fields are automatically populated all we need to do is to just create the repository key and once we have created the repository key I mean once we have created this repo it does not allow for download of the iso images or the image without specifying the username password which is problematic while installation because we would need a repo which serves images without the need for username and password so in order to do that we would need to go to the security tab and inside settings we would need to select allow anonymous access and this allows anonymous downloads for the iso and dot image root fs files that we would need to download during the installation process so once we have done that the next thing that we would need to do is to download the root fs image and then push it into the registry so it is something like this after we have pushed it so in order to push it all we need to do is to have a curl post command and then give the particular repository name and it has to push the image so I would like to show an example for this so in order to say push this particular image we would need to just post it we just need to use the put command with the appropriate generic repo name and then the image name that we would need that to be uploaded as all right so in order to do that we would need to so we would need to do the same thing for all of the images that we would need to upload to the generic repository and once we have done that we would essentially be seeing the images like as shown here essentially I have put in the root fs image the arcos live image and the bootstrap and cluster image files for the cluster so now that we have done all of these steps we have successfully set up the artifact repository for both Docker registry and then the generic repository for the root fs store so now all we have to do is just to install the hub cluster and the sno so the procedure for doing that is similar to the procedure for installing the hub cluster and single node openshift for any generic disconnected registry so if we take a look at the install config so we are providing the bootstrap os image and the cluster os image from artifact these are the ones that I just showed you as the uploaded files there and then for image content sources we need to provide the path on artifactory and keep in mind again this is 443 and not 5000 and the same thing pull secret file and the additional test bundle so I have already installed the hub cluster and this has to and this worked fine without any issues so the hub cluster got installed from the registry again I am not installing the hub cluster just in interest of time in order to in order not to make this a really long demo and once the hub cluster is installed again configuring and installing assisted installer is also in a similar way in which you just need to give the appropriate mirror registry for the cluster image set and also for the agent service while giving the url in the root of this url you need to give for the generic repository that we created as a part of the generic repository image upload and that would be it so once we have created the assisted service and then if we go ahead and deploy the sno it should get deployed successfully and let us take a look at the pre-installed sno that I have installed already so that would be all for this demo I hope this has been really useful to you and thank you.